From d2c98d6f9b59339d0b8ff741fc42682cbc97f90b Mon Sep 17 00:00:00 2001 From: Balagangadhar Bathula Date: Sat, 31 Oct 2020 23:51:14 -0400 Subject: [PATCH] Port-mapping for 7.1.0 models adds support for XPDR and ROADM 7.1.0 - copied /pasted the portmapping221 classes to create 710 versions - make needed adaptations - declare the 710 bean in blueprint JIRA: TRNSPRTPCE-337 Change-Id: I6a99b0c232d2ed037a5376d5b86f211d8f0e1020 --- .../transportpce/common/StringConstants.java | 2 +- .../common/mapping/MappingUtilsImpl.java | 2 + .../common/mapping/PortMappingImpl.java | 111 +- .../common/mapping/PortMappingVersion710.java | 1239 +++++++++++++++++ .../common/mapping/SortPort710ByName.java | 34 + .../OpenRoadmInterfacesImpl.java | 147 +- .../OpenRoadmInterfacesImpl710.java | 238 ++++ .../OSGI-INF/blueprint/common-blueprint.xml | 24 +- .../common/mapping/PortMappingImplTest.java | 5 +- .../tpce/module/TransportPCEImpl.java | 11 +- .../controllers/tpce/utils/TPCEUtils.java | 6 + .../NetConfTopologyListenerTest.java | 9 +- .../olm/OlmPowerServiceRpcImplTest.java | 13 +- .../olm/power/PowerMgmtPowerMockTest.java | 16 +- .../transportpce/olm/power/PowerMgmtTest.java | 10 +- .../OlmPowerServiceImplSpanLossBaseTest.java | 4 +- .../olm/service/OlmPowerServiceImplTest.java | 13 +- ...ceRendererServiceImplCreateOtsOmsTest.java | 14 +- ...ndererServiceOperationsImplDeleteTest.java | 11 +- .../RendererServiceOperationsImplTest.java | 11 +- 20 files changed, 1811 insertions(+), 109 deletions(-) create mode 100644 common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion710.java create mode 100644 common/src/main/java/org/opendaylight/transportpce/common/mapping/SortPort710ByName.java create mode 100644 common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl710.java diff --git a/common/src/main/java/org/opendaylight/transportpce/common/StringConstants.java b/common/src/main/java/org/opendaylight/transportpce/common/StringConstants.java index bb95bddc3..1ee6eb169 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/StringConstants.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/StringConstants.java @@ -15,7 +15,7 @@ public final class StringConstants { public static final String DEFAULT_NETCONF_NODEID = "controller-config"; public static final String OPENROADM_DEVICE_VERSION_1_2_1 = "(http://org/openroadm/device?revision=2017-02-06)org-openroadm-device"; public static final String OPENROADM_DEVICE_VERSION_2_2_1 = "(http://org/openroadm/device?revision=2018-10-19)org-openroadm-device"; - + public static final String OPENROADM_DEVICE_VERSION_7_1_0 = "(http://org/openroadm/device?revision=2020-05-29)org-openroadm-device"; public static final String NETWORK_TOKEN = "NETWORK"; diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/MappingUtilsImpl.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/MappingUtilsImpl.java index d018ef9c9..fd8ec6c2c 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/MappingUtilsImpl.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/MappingUtilsImpl.java @@ -45,6 +45,8 @@ public class MappingUtilsImpl implements MappingUtils { if (nodeInfoObj.isPresent()) { NodeInfo nodInfo = nodeInfoObj.get(); switch (nodInfo.getOpenroadmVersion()) { + case _710: + return StringConstants.OPENROADM_DEVICE_VERSION_7_1_0; case _221: return StringConstants.OPENROADM_DEVICE_VERSION_2_2_1; case _121: diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingImpl.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingImpl.java index 352781714..7dee4dbc3 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingImpl.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingImpl.java @@ -9,6 +9,7 @@ package org.opendaylight.transportpce.common.mapping; import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_1_2_1; import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_2_2_1; +import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_7_1_0; import java.util.Optional; import java.util.concurrent.ExecutionException; @@ -37,26 +38,32 @@ public class PortMappingImpl implements PortMapping { private static final Logger LOG = LoggerFactory.getLogger(PortMappingImpl.class); private final DataBroker dataBroker; + private final PortMappingVersion710 portMappingVersion710; private final PortMappingVersion221 portMappingVersion22; private final PortMappingVersion121 portMappingVersion121; - public PortMappingImpl(DataBroker dataBroker, PortMappingVersion221 portMappingVersion22, - PortMappingVersion121 portMappingVersion121) { + public PortMappingImpl(DataBroker dataBroker, PortMappingVersion710 portMappingVersion710, + PortMappingVersion221 portMappingVersion22, PortMappingVersion121 portMappingVersion121) { this.dataBroker = dataBroker; + this.portMappingVersion710 = portMappingVersion710; this.portMappingVersion22 = portMappingVersion22; this.portMappingVersion121 = portMappingVersion121; } @Override public boolean createMappingData(String nodeId, String nodeVersion) { - if (nodeVersion.equals(OPENROADM_DEVICE_VERSION_1_2_1)) { - return portMappingVersion121.createMappingData(nodeId); - } else if (nodeVersion.equals(OPENROADM_DEVICE_VERSION_2_2_1)) { - return portMappingVersion22.createMappingData(nodeId); + switch (nodeVersion) { + case OPENROADM_DEVICE_VERSION_1_2_1: + return portMappingVersion121.createMappingData(nodeId); + case OPENROADM_DEVICE_VERSION_2_2_1: + return portMappingVersion22.createMappingData(nodeId); + case OPENROADM_DEVICE_VERSION_7_1_0: + return portMappingVersion710.createMappingData(nodeId); + default: + LOG.error("Unable to create mapping data for unmanaged openroadm device version"); + return false; } - LOG.error("Unable to create mapping data for unmanaged openroadm device version"); - return false; } @@ -127,37 +134,65 @@ public class PortMappingImpl implements PortMapping { @Override public boolean updateMapping(String nodeId, Mapping oldMapping) { - OpenroadmVersion openROADMversion = this.getNode(nodeId).getNodeInfo().getOpenroadmVersion(); - if (openROADMversion.getIntValue() == 1) { - return portMappingVersion121.updateMapping(nodeId,oldMapping); - } else if (openROADMversion.getIntValue() == 2) { - org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes - .MappingBuilder oldMapping2Bldr = new MappingBuilder().setLogicalConnectionPoint(oldMapping - .getLogicalConnectionPoint()).setPortDirection(oldMapping.getPortDirection()); - if (oldMapping.getConnectionMapLcp() != null) { - oldMapping2Bldr.setConnectionMapLcp(oldMapping.getConnectionMapLcp()); - } - if (oldMapping.getPartnerLcp() != null) { - oldMapping2Bldr.setPartnerLcp(oldMapping.getPartnerLcp()); - } - if (oldMapping.getPortQual() != null) { - oldMapping2Bldr.setPortQual(oldMapping.getPortQual()); - } - if (oldMapping.getSupportingCircuitPackName() != null) { - oldMapping2Bldr.setSupportingCircuitPackName(oldMapping.getSupportingCircuitPackName()); - } - if (oldMapping.getSupportingOms() != null) { - oldMapping2Bldr.setSupportingOms(oldMapping.getSupportingOms()); - } - if (oldMapping.getSupportingOts() != null) { - oldMapping2Bldr.setSupportingOts(oldMapping.getSupportingOts()); - } - if (oldMapping.getSupportingPort() != null) { - oldMapping2Bldr.setSupportingPort(oldMapping.getSupportingPort()); - } - return portMappingVersion22.updateMapping(nodeId, oldMapping2Bldr.build()); + OpenroadmVersion openROADMversion = getNode(nodeId).getNodeInfo().getOpenroadmVersion(); + switch (openROADMversion.getIntValue()) { + case 1: + return portMappingVersion121.updateMapping(nodeId, oldMapping); + case 2: + org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes + .MappingBuilder oldMapping2Bldr221 = new MappingBuilder().setLogicalConnectionPoint(oldMapping + .getLogicalConnectionPoint()).setPortDirection(oldMapping.getPortDirection()); + if (oldMapping.getConnectionMapLcp() != null) { + oldMapping2Bldr221.setConnectionMapLcp(oldMapping.getConnectionMapLcp()); + } + if (oldMapping.getPartnerLcp() != null) { + oldMapping2Bldr221.setPartnerLcp(oldMapping.getPartnerLcp()); + } + if (oldMapping.getPortQual() != null) { + oldMapping2Bldr221.setPortQual(oldMapping.getPortQual()); + } + if (oldMapping.getSupportingCircuitPackName() != null) { + oldMapping2Bldr221.setSupportingCircuitPackName(oldMapping.getSupportingCircuitPackName()); + } + if (oldMapping.getSupportingOms() != null) { + oldMapping2Bldr221.setSupportingOms(oldMapping.getSupportingOms()); + } + if (oldMapping.getSupportingOts() != null) { + oldMapping2Bldr221.setSupportingOts(oldMapping.getSupportingOts()); + } + if (oldMapping.getSupportingPort() != null) { + oldMapping2Bldr221.setSupportingPort(oldMapping.getSupportingPort()); + } + return portMappingVersion22.updateMapping(nodeId, oldMapping2Bldr221.build()); + case 3: + org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes + .MappingBuilder oldMapping2Bldr710 = new MappingBuilder().setLogicalConnectionPoint(oldMapping + .getLogicalConnectionPoint()).setPortDirection(oldMapping.getPortDirection()); + if (oldMapping.getConnectionMapLcp() != null) { + oldMapping2Bldr710.setConnectionMapLcp(oldMapping.getConnectionMapLcp()); + } + if (oldMapping.getPartnerLcp() != null) { + oldMapping2Bldr710.setPartnerLcp(oldMapping.getPartnerLcp()); + } + if (oldMapping.getPortQual() != null) { + oldMapping2Bldr710.setPortQual(oldMapping.getPortQual()); + } + if (oldMapping.getSupportingCircuitPackName() != null) { + oldMapping2Bldr710.setSupportingCircuitPackName(oldMapping.getSupportingCircuitPackName()); + } + if (oldMapping.getSupportingOms() != null) { + oldMapping2Bldr710.setSupportingOms(oldMapping.getSupportingOms()); + } + if (oldMapping.getSupportingOts() != null) { + oldMapping2Bldr710.setSupportingOts(oldMapping.getSupportingOts()); + } + if (oldMapping.getSupportingPort() != null) { + oldMapping2Bldr710.setSupportingPort(oldMapping.getSupportingPort()); + } + return portMappingVersion710.updateMapping(nodeId, oldMapping2Bldr710.build()); + default: + return false; } - return false; } @Override diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion710.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion710.java new file mode 100644 index 000000000..bac76e0dd --- /dev/null +++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion710.java @@ -0,0 +1,1239 @@ +/* + * Copyright © 2020 AT&T, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.transportpce.common.mapping; + +import com.google.common.util.concurrent.FluentFuture; +import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; +import java.math.BigInteger; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Base64; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Optional; +import java.util.concurrent.ExecutionException; +import java.util.stream.Collectors; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.mdsal.binding.api.DataBroker; +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.StringConstants; +import org.opendaylight.transportpce.common.Timeouts; +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.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.circuit.pack.Ports; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.pack.PortsKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.packs.CircuitPacks; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.packs.CircuitPacksKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.degree.ConnectionPorts; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.Interface; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.OrgOpenroadmDevice; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.ConnectionMap; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.Degree; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.DegreeKey; +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.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.SharedRiskGroupKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.Xponder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.connection.map.Destination; +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.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.interfaces.rev191129.OpenROADMOpticalMultiplex; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.OpticalTransport; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.OtnOdu; +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.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.types.rev200327.SupportedIfCapability; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.common.Uint16; +import org.opendaylight.yangtools.yang.common.Uint32; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class PortMappingVersion710 { + private static final Logger LOG = LoggerFactory.getLogger(PortMappingVersion710.class); + + private final DataBroker dataBroker; + private final DeviceTransactionManager deviceTransactionManager; + private final OpenRoadmInterfaces openRoadmInterfaces; + //FNV1 64 bit hash constants + private static final BigInteger FNV_PRIME = new BigInteger("100000001b3", 16); + private static final BigInteger FNV_INIT = new BigInteger("cbf29ce484222325", 16); + private static final BigInteger FNV_MOD = new BigInteger("2").pow(64); + + public PortMappingVersion710(DataBroker dataBroker, DeviceTransactionManager deviceTransactionManager, + OpenRoadmInterfaces openRoadmInterfaces) { + this.dataBroker = dataBroker; + this.deviceTransactionManager = deviceTransactionManager; + this.openRoadmInterfaces = openRoadmInterfaces; + } + + public boolean createMappingData(String nodeId) { + LOG.info("Create Mapping Data for node 7.1.0 {}", nodeId); + List portMapList = new ArrayList<>(); + List mcCapabilitiesList = new ArrayList<>(); + InstanceIdentifier infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class); + Optional deviceInfoOptional = this.deviceTransactionManager.getDataFromDevice( + nodeId, LogicalDatastoreType.OPERATIONAL, infoIID, + Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); + Info deviceInfo; + NodeInfo nodeInfo; + if (!deviceInfoOptional.isPresent()) { + LOG.warn("Device info subtree is absent for {}", nodeId); + return false; + } + deviceInfo = deviceInfoOptional.get(); + nodeInfo = createNodeInfo(deviceInfo, nodeId); + if (nodeInfo == null) { + return false; + } + postPortMapping(nodeId, nodeInfo, null, null, null, null); + + switch (deviceInfo.getNodeType()) { + + case Rdm: + // Get TTP port mapping + if (!createTtpPortMapping(nodeId, deviceInfo, portMapList)) { + // return false if mapping creation for TTP's failed + LOG.warn("Unable to create mapping for TTP's on node {}", nodeId); + return false; + } + + // Get PP port mapping + if (!createPpPortMapping(nodeId, deviceInfo, portMapList)) { + // return false if mapping creation for PP's failed + LOG.warn("Unable to create mapping for PP's on node {}", nodeId); + return false; + } + // Get MC capabilities + if (!createMcCapabilitiesList(nodeId, deviceInfo, mcCapabilitiesList)) { + // return false if MC capabilites failed + LOG.warn("Unable to create MC capabilities on node {}", nodeId); + return false; + } + break; + case Xpdr: + if (!createXpdrPortMapping(nodeId, portMapList)) { + LOG.warn("Unable to create mapping for Xponder on node {}", nodeId); + return false; + } + break; + default: + LOG.error("Unable to create mapping for node {} : unknown nodetype ", nodeId); + break; + + } + return postPortMapping(nodeId, nodeInfo, portMapList, null, null, mcCapabilitiesList); + } + + public boolean updateMapping(String nodeId, Mapping oldMapping) { + InstanceIdentifier portIId = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(CircuitPacks.class, new CircuitPacksKey(oldMapping.getSupportingCircuitPackName())) + .child(Ports.class, new PortsKey(oldMapping.getSupportingPort())); + if ((oldMapping == null) || (nodeId == null)) { + LOG.error("Impossible to update mapping"); + return false; + } + try { + Optional 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()); + LOG.info("Updating old mapping Data {} for {} of {} by new mapping data {}", + oldMapping, oldMapping.getLogicalConnectionPoint(), nodeId, newMapping); + final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction(); + InstanceIdentifier mapIID = InstanceIdentifier.create(Network.class) + .child(Nodes.class, new NodesKey(nodeId)) + .child(Mapping.class, new MappingKey(oldMapping.getLogicalConnectionPoint())); + writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, mapIID, newMapping); + FluentFuture commit = writeTransaction.commit(); + commit.get(); + return true; + } catch (InterruptedException | ExecutionException e) { + LOG.error("Error updating Mapping {} for node {}", oldMapping.getLogicalConnectionPoint(), nodeId, e); + return false; + } + } + + private boolean createXpdrPortMapping(String nodeId, List portMapList) { + // Creating for Xponder Line and Client Ports + InstanceIdentifier deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class); + Optional deviceObject = deviceTransactionManager.getDataFromDevice(nodeId, + LogicalDatastoreType.OPERATIONAL, deviceIID, + Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); + OrgOpenroadmDevice device = null; + if (!deviceObject.isPresent()) { + LOG.error("Impossible to get device configuration for node {}", nodeId); + return false; + } + device = deviceObject.get(); + // Variable to keep track of number of line ports + int line = 1; + // Variable to keep track of number of client ports + int client = 1; + Map lcpMap = new HashMap<>(); + Map mappingMap = new HashMap<>(); + + List circuitPackList = null; + if (device.getCircuitPacks() == null) { + LOG.warn("Circuit Packs are not present for {}", nodeId); + return false; + } + circuitPackList = new ArrayList<>(deviceObject.get().nonnullCircuitPacks().values()); + circuitPackList.sort(Comparator.comparing(CircuitPack::getCircuitPackName)); + + if (device.getXponder() == null) { + LOG.warn("{} configuration does not contain a list of xponders", nodeId); + for (CircuitPacks cp : circuitPackList) { + String circuitPackName = cp.getCircuitPackName(); + if (cp.getPorts() == null) { + LOG.warn("Ports were not found for circuit pack: {}", circuitPackName); + continue; + } + List portList = new ArrayList<>(cp.nonnullPorts().values()); + portList.sort(Comparator.comparing(Ports::getPortName)); + for (Ports port : portList) { + if (port.getPortQual() == null) { + LOG.warn("PortQual was not found for port {} on circuit pack: {}", port.getPortName(), + circuitPackName); + continue; + } + if (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, + null, null)); + line++; + } else if (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 cpOpt = circuitPackList.stream() + .filter(cP -> cP.getCircuitPackName().equals(port.getPartnerPort().getCircuitPackName())) + .findFirst(); + if (cpOpt.isPresent()) { + Optional poOpt = cpOpt.get().nonnullPorts().values().stream() + .filter(p -> p.getPortName().equals(port.getPartnerPort().getPortName().toString())) + .findFirst(); + if (poOpt.isPresent()) { + Ports port2 = poOpt.get(); + if (checkPartnerPort(circuitPackName, port, port2)) { + 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, null)); + mappingMap.put(lcp2, createXpdrMappingObject(nodeId, port2, cpOpt.get() + .getCircuitPackName(), lcp2, lcp1, null, 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 (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, + null, null)); + client++; + } else { + LOG.warn("Error in the configuration of port {} of {} for {}", port.getPortName(), + circuitPackName, + nodeId); + } + } + } + } else { + LOG.info("{} configuration contains a list of xponders", nodeId); + for (Xponder xponder:deviceObject.get().nonnullXponder().values()) { + line = 1; + client = 1; + Integer xponderNb = xponder.getXpdrNumber().toJava(); + XpdrNodeTypes xponderType = xponder.getXpdrType(); + for (XpdrPort xpdrPort : xponder.nonnullXpdrPort().values()) { + String circuitPackName = xpdrPort.getCircuitPackName(); + String portName = xpdrPort.getPortName().toString(); + // 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()) { + LOG.warn("Circuit-pack {} is missing in the device", circuitPackName); + LOG.warn("Port-mapping will continue ignoring this circuit-pack {}", 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()) { + LOG.warn("Port {} associated with CP {} is missing in the device", portName, circuitPackName); + LOG.warn("Port-mapping will continue ignoring this port {}", portName); + 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(); + if (port.getPortQual() == null) { + LOG.warn("PortQual was not found for port {} on circuit pack: {}", port.getPortName(), + circuitPackName); + continue; + } + if ((PortQual.XpdrNetwork.getIntValue() == port.getPortQual().getIntValue() + || PortQual.SwitchNetwork.getIntValue() == port.getPortQual().getIntValue()) + && port.getPortDirection().getIntValue() == Direction.Bidirectional.getIntValue()) { + String lcp = "XPDR" + xponderNb + "-" + StringConstants.NETWORK_TOKEN + line; + lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp); + mappingMap.put(lcp, createXpdrMappingObject(nodeId, port, circuitPackName, lcp, + null, null, null, xponderType)); + line++; + } else if ((PortQual.XpdrNetwork.getIntValue() == port.getPortQual().getIntValue() + || PortQual.SwitchNetwork.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 = "XPDR" + xponderNb + "-" + StringConstants.NETWORK_TOKEN + line; + + Optional cpOpt = circuitPackList.stream() + .filter(cP -> cP.getCircuitPackName().equals(port.getPartnerPort().getCircuitPackName())) + .findFirst(); + if (cpOpt.isPresent()) { + Optional poOpt = cpOpt.get().nonnullPorts().values().stream() + .filter(p -> p.getPortName().equals(port.getPartnerPort().getPortName().toString())) + .findFirst(); + if (poOpt.isPresent()) { + Ports port2 = poOpt.get(); + if (checkPartnerPort(circuitPackName, port, port2)) { + String lcp2 = new StringBuilder("XPDR").append(xponderNb).append("-").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, xponderType)); + mappingMap.put(lcp2, createXpdrMappingObject(nodeId, port2, cpOpt.get() + .getCircuitPackName(), lcp2, lcp1, null, null, + xponderType)); + } 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 (PortQual.XpdrClient.getIntValue() == port.getPortQual().getIntValue() + || PortQual.SwitchClient.getIntValue() == port.getPortQual().getIntValue()) { + String lcp = "XPDR" + xponderNb + "-" + StringConstants.CLIENT_TOKEN + client; + lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp); + mappingMap.put(lcp, createXpdrMappingObject(nodeId, port, circuitPackName, lcp, + null, null, null, null)); + client++; + } else { + LOG.warn("Error in the configuration of port {} of {} for {}", port.getPortName(), + circuitPackName, nodeId); + } + } + } + } + + if (device.getConnectionMap() != null) { + Collection connectionMap = deviceObject.get().nonnullConnectionMap().values(); + String slcp = null; + String dlcp = null; + for (ConnectionMap cm : connectionMap) { + String skey = cm.getSource().getCircuitPackName() + "+" + cm.getSource().getPortName(); + if (lcpMap.containsKey(skey)) { + slcp = lcpMap.get(skey); + } + Destination destination0 = cm.nonnullDestination().values().iterator().next(); + String dkey = destination0.getCircuitPackName() + "+" + destination0.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, null)); + } else { + LOG.error("Error in connection-map analysis"); + } + } + } else { + LOG.warn("No connection-map inside device configuration"); + } + if (device.getOduSwitchingPools() != null) { + Collection oduSwithcingPools = device.nonnullOduSwitchingPools().values(); + List switchingPoolList = new ArrayList<>(); + for (OduSwitchingPools odp : oduSwithcingPools) { + Map nbMap = new HashMap<>(); + for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org + .openroadm.device.odu.switching.pools.NonBlockingList nbl : odp.nonnullNonBlockingList().values()) { + List lcpList = new ArrayList<>(); + if (nbl.getPortList() != null) { + for (PortList item : nbl.nonnullPortList().values()) { + String key = item.getCircuitPackName() + "+" + item.getPortName(); + if (lcpMap.containsKey(key)) { + lcpList.add(lcpMap.get(key)); + } else { + LOG.error("error : port {} of {} is not associated to a logical connection point", + item.getPortName(), item.getCircuitPackName()); + } + } + NonBlockingList nonBlockingList = new NonBlockingListBuilder() + .setNblNumber(nbl.getNblNumber()) + .setInterconnectBandwidth(nbl.getInterconnectBandwidth()) + .setInterconnectBandwidthUnit(nbl.getInterconnectBandwidthUnit()) + .setLcpList(lcpList) + .build(); + nbMap.put(nonBlockingList.key(),nonBlockingList); + } + } + SwitchingPoolLcp splBldr = new SwitchingPoolLcpBuilder() + .setSwitchingPoolNumber(odp.getSwitchingPoolNumber()) + .setSwitchingPoolType(odp.getSwitchingPoolType()) + .setNonBlockingList(nbMap) + .build(); + switchingPoolList.add(splBldr); + } + postPortMapping(nodeId, null, null, null, switchingPoolList, null); + } + + if (!mappingMap.isEmpty()) { + mappingMap.forEach((k,v) -> portMapList.add(v)); + } + return true; + } + + private boolean checkPartnerPort(String circuitPackName, Ports port1, Ports port2) { + if ((Direction.Rx.getIntValue() == port1.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(port1.getPortName())) + || + (Direction.Tx.getIntValue() == port1.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(port1.getPortName()))) { + return true; + } else { + return false; + } + } + + + private HashMap> getSrgCps(String deviceId, Info ordmInfo) { + HashMap> cpPerSrg = new HashMap<>(); + Integer maxSrg; + // Get value for max Srg from info subtree, required for iteration + // if not present assume to be 20 (temporary) + if (ordmInfo.getMaxSrgs() != null) { + maxSrg = ordmInfo.getMaxSrgs().toJava(); + } else { + maxSrg = 20; + } + for (int srgCounter = 1; srgCounter <= maxSrg; srgCounter++) { + List srgCps + = new ArrayList<>(); + LOG.info("Getting Circuitpacks for Srg Number {}", srgCounter); + InstanceIdentifier srgIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(SharedRiskGroup.class, new SharedRiskGroupKey(Uint16.valueOf(srgCounter))); + Optional ordmSrgObject = this.deviceTransactionManager.getDataFromDevice(deviceId, + LogicalDatastoreType.OPERATIONAL, srgIID, + Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); + if (ordmSrgObject.isPresent()) { + srgCps.addAll(ordmSrgObject.get().nonnullCircuitPacks().values()); + cpPerSrg.put(ordmSrgObject.get().getSrgNumber().toJava(), srgCps); + } + } + LOG.info("Device {} has {} Srg", deviceId, cpPerSrg.size()); + return cpPerSrg; + } + + //last LOG info message in this method is too long + @SuppressWarnings("checkstyle:linelength") + private boolean createPpPortMapping(String nodeId, Info deviceInfo, List portMapList) { + // Creating mapping data for SRG's PP + HashMap> srgCps + = getSrgCps(nodeId, deviceInfo); + for (Entry> srgCpEntry : srgCps.entrySet()) { + List cpList = + srgCps.get(srgCpEntry.getKey()); + List keys = new ArrayList<>(); + for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.srg.CircuitPacks cp : cpList) { + String circuitPackName = cp.getCircuitPackName(); + InstanceIdentifier cpIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName)); + Optional circuitPackObject = this.deviceTransactionManager.getDataFromDevice(nodeId, + LogicalDatastoreType.OPERATIONAL, cpIID, + Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); + + if (!circuitPackObject.isPresent() || (circuitPackObject.get().getPorts() == null)) { + LOG.warn("{} : Circuit pack {} not found or without ports.", nodeId, circuitPackName); + continue; + } + List portList = new ArrayList<>(circuitPackObject.get().nonnullPorts().values()); + Collections.sort(portList, new SortPort710ByName()); + 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() + && Direction.Bidirectional.getIntValue() == port.getPortDirection().getIntValue() + && !keys.contains(currentKey)) { + String logicalConnectionPoint = createLogicalConnectionPort(port, srgCpEntry.getKey(), 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 (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, srgCpEntry.getKey(), portIndex); + LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, circuitPackName, + port.getPortName(), logicalConnectionPoint1); + InstanceIdentifier port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(CircuitPacks.class, new CircuitPacksKey(port.getPartnerPort().getCircuitPackName())) + .child(Ports.class, new PortsKey(port.getPartnerPort().getPortName().toString())); + Optional port2Object = this.deviceTransactionManager.getDataFromDevice(nodeId, + LogicalDatastoreType.OPERATIONAL, port2ID, + Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); + if (port2Object.isPresent() + && port2Object.get().getPortQual().getIntValue() + == PortQual.RoadmExternal.getIntValue()) { + Ports port2 = port2Object.get(); + if (checkPartnerPort(circuitPackName, port, port2)) { + String logicalConnectionPoint2 = createLogicalConnectionPort(port2, srgCpEntry.getKey(), 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 or has already been handled. No logicalConnectionPoint assignment for this port.", + nodeId, port.getPortName(), circuitPackName); + } + } + } + } + return true; + } + + private String createLogicalConnectionPort(Ports port, int index, int portIndex) { + String lcp = null; + switch (port.getPortDirection()) { + case Tx: + lcp = "SRG" + index + "-PP" + portIndex + "-TX"; + break; + case Rx: + lcp = "SRG" + index + "-PP" + portIndex + "-RX"; + break; + case Bidirectional: + lcp = "SRG" + index + "-PP" + portIndex + "-TXRX"; + break; + default: + LOG.error("Unsupported port direction for port {} : {}", port, port.getPortDirection()); + } + return lcp; + } + + private Map getMcCapabilityProfiles(String deviceId, Info ordmInfo) { + Map mcCapabilityProfiles = new HashMap<>(); + InstanceIdentifier deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class); + Optional deviceObject = deviceTransactionManager.getDataFromDevice(deviceId, + LogicalDatastoreType.OPERATIONAL, deviceIID, + Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); + OrgOpenroadmDevice device = null; + if (!deviceObject.isPresent()) { + LOG.error("Impossible to get device configuration for node {}", deviceId); + LOG.warn("MC-capabilities profile will be empty for node {}", deviceId); + return mcCapabilityProfiles; + } + device = deviceObject.get(); + mcCapabilityProfiles = device.getMcCapabilityProfile(); + return mcCapabilityProfiles; + } + + private List getDegrees(String deviceId, Info ordmInfo) { + List degrees = new ArrayList<>(); + Integer maxDegree; + + // Get value for max degree from info subtree, required for iteration + // if not present assume to be 20 (temporary) + if (ordmInfo.getMaxDegrees() != null) { + maxDegree = ordmInfo.getMaxDegrees().toJava(); + } else { + maxDegree = 20; + } + + for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) { + LOG.info("Getting Connection ports for Degree Number {}", degreeCounter); + InstanceIdentifier deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Degree.class, new DegreeKey(Uint16.valueOf(degreeCounter))); + Optional 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", deviceId, degrees.size()); + return degrees; + } + + private List getSrgs(String deviceId, Info ordmInfo) { + List srgs = new ArrayList<>(); + + Integer maxSrg; + // Get value for max Srg from info subtree, required for iteration + // if not present assume to be 20 (temporary) + if (ordmInfo.getMaxSrgs() != null) { + maxSrg = ordmInfo.getMaxSrgs().toJava(); + } else { + maxSrg = 20; + } + for (int srgCounter = 1; srgCounter <= maxSrg; srgCounter++) { + InstanceIdentifier srgIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(SharedRiskGroup.class, new SharedRiskGroupKey(Uint16.valueOf(srgCounter))); + Optional ordmSrgObject = this.deviceTransactionManager.getDataFromDevice(deviceId, + LogicalDatastoreType.OPERATIONAL, srgIID, + Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); + if (ordmSrgObject.isPresent()) { + srgs.add(ordmSrgObject.get()); + + } + } + return srgs; + } + + private Map> getPerDegreePorts(String deviceId, Info ordmInfo) { + Map> conPortMap = new HashMap<>(); + Integer maxDegree; + + if (ordmInfo.getMaxDegrees() != null) { + maxDegree = ordmInfo.getMaxDegrees().toJava(); + } else { + maxDegree = 20; + } + for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) { + LOG.info("Getting Connection ports for Degree Number {}", degreeCounter); + InstanceIdentifier deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Degree.class, new DegreeKey(Uint16.valueOf(degreeCounter))); + Optional ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId, + LogicalDatastoreType.OPERATIONAL, deviceIID, + Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); + if (ordmDegreeObject.isPresent()) { + conPortMap.put(degreeCounter, new ArrayList<>(ordmDegreeObject.get() + .nonnullConnectionPorts().values())); + } + } + LOG.info("Device {} has {} degree", deviceId, conPortMap.size()); + return conPortMap; + } + + private Map getEthInterfaceList(String nodeId) { + LOG.info("It is calling get ethernet interface"); + Map cpToInterfaceMap = new HashMap<>(); + InstanceIdentifier protocoliid = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Protocols.class); + Optional protocolObject = this.deviceTransactionManager.getDataFromDevice(nodeId, + LogicalDatastoreType.OPERATIONAL, protocoliid, Timeouts.DEVICE_READ_TIMEOUT, + Timeouts.DEVICE_READ_TIMEOUT_UNIT); + if (protocolObject.isPresent() && protocolObject.get().augmentation(Protocols1.class).getLldp() != null) { + Lldp lldp = protocolObject.get().augmentation(Protocols1.class).getLldp(); + for (PortConfig portConfig : lldp.nonnullPortConfig().values()) { + if (portConfig.getAdminStatus().equals(PortConfig.AdminStatus.Txandrx)) { + InstanceIdentifier interfaceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Interface.class, new InterfaceKey(portConfig.getIfName())); + Optional interfaceObject = this.deviceTransactionManager.getDataFromDevice(nodeId, + LogicalDatastoreType.OPERATIONAL, interfaceIID, Timeouts.DEVICE_READ_TIMEOUT, + Timeouts.DEVICE_READ_TIMEOUT_UNIT); + if (interfaceObject.isPresent() && (interfaceObject.get().getSupportingCircuitPackName() != null)) { + String supportingCircuitPackName = interfaceObject.get().getSupportingCircuitPackName(); + cpToInterfaceMap.put(supportingCircuitPackName, portConfig.getIfName()); + InstanceIdentifier circuitPacksIID = InstanceIdentifier + .create(OrgOpenroadmDevice.class) + .child(CircuitPacks.class, new CircuitPacksKey(supportingCircuitPackName)); + Optional circuitPackObject = this.deviceTransactionManager.getDataFromDevice( + 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()); + } + } + } + } + } else { + LOG.warn("Couldnt find port config under LLDP for Node : {}", nodeId); + } + LOG.info("Processiong is done.. now returning.."); + return cpToInterfaceMap; + } + + private List getCpToDegreeList(List degrees, String nodeId, + Map interfaceList) { + List cpToDegreeList = new ArrayList<>(); + for (Degree degree : degrees) { + if (degree.getCircuitPacks() != null) { + LOG.info("Inside CP to degree list"); + cpToDegreeList.addAll(degree.nonnullCircuitPacks().values().stream() + .map(cp -> createCpToDegreeObject(cp.getCircuitPackName(), + degree.getDegreeNumber().toString(), nodeId, interfaceList)) + .collect(Collectors.toList())); + } + } + return cpToDegreeList; + } + + private List getMcCapabilitiesList(List degrees, List srgs, + Info deviceInfo, String nodeId) { + LOG.info("Getting the MC capabilities for degrees of node {}", nodeId); + //Get all the mc-capability profiles from the device + Map mcCapabilityProfiles = getMcCapabilityProfiles(nodeId, + deviceInfo); + // Add the DEG mc-capabilities + List mcCapabilitiesList = createMcCapDegreeObject(degrees, mcCapabilityProfiles, nodeId); + // Add the SRG mc-capabilities + LOG.info("Getting the MC capabilities for SRGs of node {}", nodeId); + mcCapabilitiesList.addAll(createMcCapSrgObject(srgs, mcCapabilityProfiles, nodeId)); + + return mcCapabilitiesList; + } + + private boolean postPortMapping(String nodeId, NodeInfo nodeInfo, List portMapList, + List cp2DegreeList, List splList, List mcCapList) { + NodesBuilder nodesBldr = new NodesBuilder().withKey(new NodesKey(nodeId)).setNodeId(nodeId); + if (nodeInfo != null) { + nodesBldr.setNodeInfo(nodeInfo); + } + if (portMapList != null) { + Map mappingMap = new HashMap<>(); + for (Mapping mapping: portMapList) { + if (mapping != null) { + mappingMap.put(mapping.key(), mapping); + } + } + nodesBldr.setMapping(mappingMap); + } + if (cp2DegreeList != null) { + Map cpToDegreeMap = new HashMap<>(); + for (CpToDegree cp2Degree: cp2DegreeList) { + if (cp2Degree != null) { + cpToDegreeMap.put(cp2Degree.key(), cp2Degree); + } + } + nodesBldr.setCpToDegree(cpToDegreeMap); + } + + if (splList != null) { + Map splMap = new HashMap<>(); + for (SwitchingPoolLcp spl: splList) { + if (spl != null) { + splMap.put(spl.key(), spl); + } + } + nodesBldr.setSwitchingPoolLcp(splMap); + } + if (mcCapList != null) { + nodesBldr.setMcCapabilities(mcCapList); + } + Map nodesList = new HashMap<>(); + Nodes nodes = nodesBldr.build(); + nodesList.put(nodes.key(),nodes); + + NetworkBuilder nwBldr = new NetworkBuilder().setNodes(nodesList); + + final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction(); + InstanceIdentifier nodesIID = InstanceIdentifier.builder(Network.class).build(); + Network network = nwBldr.build(); + writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, nodesIID, network); + FluentFuture commit = writeTransaction.commit(); + try { + commit.get(); + return true; + } catch (InterruptedException | ExecutionException e) { + LOG.warn("Failed to post {}", network, e); + return false; + } + } + + private CpToDegree createCpToDegreeObject(String circuitPackName, String degreeNumber, String nodeId, + Map interfaceList) { + String interfaceName = null; + if (interfaceList.get(circuitPackName) != null) { + interfaceName = interfaceList.get(circuitPackName); + } + return new CpToDegreeBuilder().withKey(new CpToDegreeKey(circuitPackName)).setCircuitPackName(circuitPackName) + .setDegreeNumber(Uint32.valueOf(degreeNumber)).setInterfaceName(interfaceName).build(); + } + + private List createMcCapDegreeObject(List degrees, + Map mcCapabilityProfileMap, String nodeId) { + List mcCapabilitiesList = new ArrayList<>(); + for (Degree degree : degrees) { + if (!degree.getMcCapabilityProfileName().isEmpty()) { + for (String mcCapabilityProfileName : degree.getMcCapabilityProfileName()) { + McCapabilityProfileKey mcKey = new McCapabilityProfileKey(mcCapabilityProfileName); + McCapabilityProfile mcCapabilityProfile = mcCapabilityProfileMap.get(mcKey); + String mcNodeName = "DEG" + degree.getDegreeNumber().toString() + "-TTP-" + mcCapabilityProfile; + McCapabilitiesBuilder mcCapabilitiesBuilder = new McCapabilitiesBuilder() + .withKey(new McCapabilitiesKey(mcNodeName)) + .setMcNodeName(mcNodeName); + mcCapabilitiesBuilder + .setCenterFreqGranularity(mcCapabilityProfile.getCenterFreqGranularity()) + .setSlotWidthGranularity(mcCapabilityProfile.getSlotWidthGranularity()); + mcCapabilitiesList.add(mcCapabilitiesBuilder.build()); + } // end for + } + else { + LOG.warn("No MC profiles are found for node {} on degree {}", nodeId, degree.getDegreeNumber()); + LOG.warn("Assuming the fixed grid capabilities for degree {}", degree.getDegreeNumber()); + LOG.warn("Assuming a default MC profile-name for degree {}", degree.getDegreeNumber()); + String mcNodeName = "DEG" + degree.getDegreeNumber().toString() + "-TTP-" + "default-profile"; + McCapabilitiesBuilder mcCapabilitiesBuilder = new McCapabilitiesBuilder() + .withKey(new McCapabilitiesKey(mcNodeName)) + .setMcNodeName(mcNodeName); + mcCapabilitiesBuilder + .setCenterFreqGranularity(FrequencyGHz.getDefaultInstance("50")) + .setSlotWidthGranularity(FrequencyGHz.getDefaultInstance("50")); + } + } + return mcCapabilitiesList; + } + + private List createMcCapSrgObject(List srgs, + Map mcCapabilityProfileMap, String nodeId) { + List mcCapabilitiesList = new ArrayList<>(); + for (SharedRiskGroup srg : srgs) { + if (!srg.getMcCapabilityProfileName().isEmpty()) { + for (String mcCapabilityProfileName : srg.getMcCapabilityProfileName()) { + McCapabilityProfileKey mcKey = new McCapabilityProfileKey(mcCapabilityProfileName); + McCapabilityProfile mcCapabilityProfile = mcCapabilityProfileMap.get(mcKey); + String mcNodeName = "SRG" + srg.getSrgNumber().toString() + "-PP-" + mcCapabilityProfile; + McCapabilitiesBuilder mcCapabilitiesBuilder = new McCapabilitiesBuilder() + .withKey(new McCapabilitiesKey(mcNodeName)) + .setMcNodeName(mcNodeName); + mcCapabilitiesBuilder + .setCenterFreqGranularity(mcCapabilityProfile.getCenterFreqGranularity()) + .setSlotWidthGranularity(mcCapabilityProfile.getSlotWidthGranularity()); + mcCapabilitiesList.add(mcCapabilitiesBuilder.build()); + } // end for + } + else { + LOG.warn("No MC profiles are found for node {} on SRG {}", nodeId, srg.getSrgNumber()); + LOG.warn("Assuming the fixed grid capabilities for SRG {}", srg.getSrgNumber()); + LOG.warn("Assuming a default MC profile-name for SRG {}", srg.getSrgNumber()); + String mcNodeName = "SRG" + srg.getSrgNumber().toString() + "-PP-" + "default-profile"; + McCapabilitiesBuilder mcCapabilitiesBuilder = new McCapabilitiesBuilder() + .withKey(new McCapabilitiesKey(mcNodeName)) + .setMcNodeName(mcNodeName); + mcCapabilitiesBuilder + .setCenterFreqGranularity(FrequencyGHz.getDefaultInstance("50")) + .setSlotWidthGranularity(FrequencyGHz.getDefaultInstance("50")); + } + } + return mcCapabilitiesList; + } + + 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()); + + // Get OMS and OTS interface provisioned on the TTP's + if ((logicalConnectionPoint.contains(StringConstants.TTP_TOKEN) + || logicalConnectionPoint.contains(StringConstants.NETWORK_TOKEN)) && (port.getInterfaces() != null)) { + for (Interfaces interfaces : port.getInterfaces()) { + try { + Optional openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId, + interfaces.getInterfaceName()); + if (openRoadmInterface.isPresent()) { + LOG.info("interface get from device is {} and of type {}", openRoadmInterface.get().getName(), + openRoadmInterface.get().getType()); + Class interfaceType + = (Class) openRoadmInterface.get().getType(); + // Check if interface type is OMS or OTS + if (interfaceType.equals(OpenROADMOpticalMultiplex.class)) { + mpBldr.setSupportingOms(interfaces.getInterfaceName()); + } + if (interfaceType.equals(OpticalTransport.class)) { + mpBldr.setSupportingOts(interfaces.getInterfaceName()); + } + if (interfaceType.equals(OtnOdu.class)) { + mpBldr.setSupportingOdu4(interfaces.getInterfaceName()); + } + } else { + LOG.warn("Interface {} from node {} was null!", interfaces.getInterfaceName(), nodeId); + } + } catch (OpenRoadmInterfaceException ex) { + LOG.warn("Error while getting interface {} from node {}!", interfaces.getInterfaceName(), nodeId, + ex); + } + } + } + return mpBldr.build(); + } + + private Mapping createXpdrMappingObject(String nodeId, Ports ports, String circuitPackName, + String logicalConnectionPoint, String partnerLcp, Mapping mapping, String connectionMapLcp, + XpdrNodeTypes xpdrNodeType) { + MappingBuilder mpBldr; + if (mapping != null && connectionMapLcp != null) { + // update existing mapping + mpBldr = new MappingBuilder(mapping).setConnectionMapLcp(connectionMapLcp); + } else { + // create a new mapping + String nodeIdLcp = nodeId + "-" + logicalConnectionPoint; + mpBldr = new MappingBuilder() + .withKey(new MappingKey(logicalConnectionPoint)) + .setLogicalConnectionPoint(logicalConnectionPoint) + .setSupportingCircuitPackName(circuitPackName) + .setSupportingPort(ports.getPortName()) + .setPortDirection(ports.getPortDirection().getName()) + .setLcpHashVal(fnv(nodeIdLcp)); + + if (ports.getPortQual() != null) { + mpBldr.setPortQual(ports.getPortQual().getName()); + } + + if (ports.augmentation(Ports1.class).getPortCapabilities().getSupportedInterfaceCapability() != null) { + mpBldr.setSupportedInterfaceCapability(getSupportedIfCapability(ports)); + } + + if (xpdrNodeType != null) { + mpBldr.setXponderType(xpdrNodeType); + } + if (partnerLcp != null) { + mpBldr.setPartnerLcp(partnerLcp); + } + } + return mpBldr.build(); + } + + + private List> getSupportedIfCapability(Ports ports) { + Map supportedInterfaceCapabilityMap = + ports.augmentation(Ports1.class).getPortCapabilities().getSupportedInterfaceCapability(); + List> supportedInterfaceCapabilityList = new ArrayList<>(); + + supportedInterfaceCapabilityMap.forEach((k, v) -> supportedInterfaceCapabilityList.add(k.getIfCapType())); + return supportedInterfaceCapabilityList; + } + + private boolean createMcCapabilitiesList(String nodeId, Info deviceInfo, List mcCapabilitiesList) { + List degrees = getDegrees(nodeId, deviceInfo); + List srgs = getSrgs(nodeId, deviceInfo); + mcCapabilitiesList.addAll(getMcCapabilitiesList(degrees, srgs, deviceInfo, nodeId)); + + return true; + } + + //some LOG messages are too long + @SuppressWarnings("checkstyle:linelength") + @SuppressFBWarnings("DM_CONVERT_CASE") + private boolean createTtpPortMapping(String nodeId, Info deviceInfo, List portMapList) { + // Creating mapping data for degree TTP's + List degrees = getDegrees(nodeId, deviceInfo); + Map interfaceList = getEthInterfaceList(nodeId); + List cpToDegreeList = getCpToDegreeList(degrees, nodeId, interfaceList); + LOG.info("Map looks like this {}", interfaceList); + postPortMapping(nodeId, null, null, cpToDegreeList, null, null); + + Map> connectionPortMap = getPerDegreePorts(nodeId, deviceInfo); + for (Entry> cpMapEntry : connectionPortMap.entrySet()) { + switch (connectionPortMap.get(cpMapEntry.getKey()).size()) { + case 1: + // port is bidirectional + InstanceIdentifier portID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .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())); + LOG.info("Fetching connection-port {} at circuit pack {}", connectionPortMap.get(cpMapEntry.getKey()).get(0) + .getPortName().toString(), connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName()); + Optional 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 (PortQual.RoadmExternal.getIntValue() == port.getPortQual().getIntValue() + && Direction.Bidirectional.getIntValue() == port.getPortDirection().getIntValue()) { + String logicalConnectionPoint = new StringBuilder("DEG").append(cpMapEntry.getKey()).append("-TTP-TXRX") + .toString(); + LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, + connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), port.getPortName(), + logicalConnectionPoint); + portMapList.add(createMappingObject(nodeId, port, + connectionPortMap.get(cpMapEntry.getKey()).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(cpMapEntry.getKey()).get(0).getCircuitPackName(), nodeId); + } + } else { + LOG.error("No port {} on circuit pack {} for node {}", + connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString(), + connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), nodeId); + return false; + } + break; + case 2: + // ports are unidirectionals + String cp1Name = connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(); + String cp2Name = connectionPortMap.get(cpMapEntry.getKey()).get(1).getCircuitPackName(); + InstanceIdentifier port1ID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(CircuitPacks.class, new CircuitPacksKey(cp1Name)) + .child(Ports.class, new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString())); + LOG.info("Fetching connection-port {} at circuit pack {}", connectionPortMap.get(cpMapEntry.getKey()).get(0) + .getPortName().toString(), cp1Name); + Optional port1Object = this.deviceTransactionManager.getDataFromDevice(nodeId, + LogicalDatastoreType.OPERATIONAL, port1ID, Timeouts.DEVICE_READ_TIMEOUT, + Timeouts.DEVICE_READ_TIMEOUT_UNIT); + InstanceIdentifier port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(CircuitPacks.class, new CircuitPacksKey(cp2Name)) + .child(Ports.class, new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName().toString())); + LOG.info("Fetching connection-port {} at circuit pack {}", + connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName().toString(), cp2Name); + Optional 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 ((PortQual.RoadmExternal.getIntValue() == port1.getPortQual().getIntValue() + && 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()) + && port2.getPartnerPort().getCircuitPackName().equals(cp1Name) + && port2.getPartnerPort().getPortName().equals(port1.getPortName())) + || + (PortQual.RoadmExternal.getIntValue() == port1.getPortQual().getIntValue() + && 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()) + && port2.getPartnerPort().getCircuitPackName().equals(cp1Name) + && port2.getPartnerPort().getPortName().equals(port1.getPortName()))) { + String logicalConnectionPoint1 = new StringBuilder("DEG").append(cpMapEntry.getKey()).append("-TTP-") + .append(port1.getPortDirection().getName().toUpperCase()).toString(); + LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, + connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), port1.getPortName(), + logicalConnectionPoint1); + 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()).toString(); + LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, + connectionPortMap.get(cpMapEntry.getKey()).get(1).getCircuitPackName(), port2.getPortName(), + logicalConnectionPoint2); + portMapList.add(createMappingObject(nodeId, port2, connectionPortMap.get(cpMapEntry.getKey()).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(cpMapEntry.getKey()).get(0).getPortName().toString(), + connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), nodeId); + return false; + } + + break; + default: + LOG.error("Number of connection port for DEG{} on {} is incorrect", cpMapEntry.getKey(), nodeId); + continue; + } + } + return true; + } + + private NodeInfo createNodeInfo(Info deviceInfo, String nodeId) { + NodeInfoBuilder nodeInfoBldr = new NodeInfoBuilder(); + if (deviceInfo.getNodeType() == null) { + // TODO make mandatory in yang + LOG.error("Node type field is missing"); + return null; + } + + nodeInfoBldr.setOpenroadmVersion(OpenroadmVersion._710).setNodeType(deviceInfo.getNodeType()); + if (deviceInfo.getClli() != null && !deviceInfo.getClli().isEmpty()) { + nodeInfoBldr.setNodeClli(deviceInfo.getClli()); + } else { + nodeInfoBldr.setNodeClli("defaultCLLI"); + } + + if (deviceInfo.getModel() != null) { + nodeInfoBldr.setNodeModel(deviceInfo.getModel()); + } + + if (deviceInfo.getVendor() != null) { + nodeInfoBldr.setNodeVendor(deviceInfo.getVendor()); + } + + if (deviceInfo.getIpAddress() != null) { + nodeInfoBldr.setNodeIpAddress(deviceInfo.getIpAddress()); + } + + return nodeInfoBldr.build(); + } + + /** + * Implements the FNV-1 64bit algorithm. + * FNV-1 128bit would be ideal for 16 bytes but we need an overhead for Base64 encoding. + * Otherwise, the hash cannot be stored in a UTF-8 string. + * https://www.wikiwand.com/en/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#/FNV-1_hash + * https://github.com/pmdamora/fnv-cracker-app/blob/master/src/main/java/passwordcrack/cracking/HashChecker.java + * @param stringdata the String to be hashed + * @return the hash string + */ + private String fnv(String stringdata) { + BigInteger hash = FNV_INIT; + byte[] data = stringdata.getBytes(StandardCharsets.UTF_8); + + for (byte b : data) { + hash = hash.multiply(FNV_PRIME).mod(FNV_MOD); + hash = hash.xor(BigInteger.valueOf((int) b & 0xff)); + } + + return Base64.getEncoder().encodeToString(hash.toByteArray()); + } +} diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/SortPort710ByName.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/SortPort710ByName.java new file mode 100644 index 000000000..676f6e00f --- /dev/null +++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/SortPort710ByName.java @@ -0,0 +1,34 @@ +/* + * Copyright © 2020 AT&T, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.transportpce.common.mapping; + +import java.io.Serializable; +import java.util.Comparator; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.Port; + +/** + * Class to compare two String containing integer. + * + * @author Martial Coulibaly (martial.coulibaly@gfi.com) on behalf of Orange + * + */ +@edu.umd.cs.findbugs.annotations.SuppressFBWarnings( + value = "SE_NO_SERIALVERSIONID", + justification = "https://github.com/rzwitserloot/lombok/wiki/WHY-NOT:-serialVersionUID") +public class SortPort710ByName implements Comparator, Serializable { + + @Override + public int compare(Port port1, Port port2) { + return extractInt(port1) - extractInt(port2); + } + + private int extractInt(Port port) { + String num = port.getPortName().replaceAll("\\D", ""); + return num.isEmpty() ? 0 : Integer.parseInt(num); + } +} diff --git a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl.java b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl.java index 9363a44b8..1f5fcf6bf 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl.java @@ -10,6 +10,7 @@ package org.opendaylight.transportpce.common.openroadminterfaces; import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_1_2_1; import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_2_2_1; +import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_7_1_0; import java.util.Optional; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; @@ -25,31 +26,45 @@ public class OpenRoadmInterfacesImpl implements OpenRoadmInterfaces { OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221; + OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710; MappingUtils mappingUtils; public OpenRoadmInterfacesImpl(DeviceTransactionManager deviceTransactionManager, MappingUtils mappingUtils, OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121, - OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221) { + OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221, + OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710) { this.mappingUtils = mappingUtils; this.openRoadmInterfacesImpl121 = openRoadmInterfacesImpl121; this.openRoadmInterfacesImpl221 = openRoadmInterfacesImpl221; + this.openRoadmInterfacesImpl710 = openRoadmInterfacesImpl710; } @Override public void postInterface(String nodeId, T ifBuilder) throws OpenRoadmInterfaceException { - String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId); - if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_1_2_1)) { - LOG.info("postInterface for 1.2.1 device {}", nodeId); - InterfaceBuilder ifBuilder121 = convertInstanceOfInterface(ifBuilder, InterfaceBuilder.class); - openRoadmInterfacesImpl121.postInterface(nodeId,ifBuilder121); - } - else if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_2_2_1)) { - LOG.info("postInterface for 2.2.1 device {}", nodeId); - org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder - ifBuilder22 = convertInstanceOfInterface(ifBuilder, org.opendaylight.yang.gen.v1.http.org.openroadm - .device.rev181019.interfaces.grp.InterfaceBuilder.class); - openRoadmInterfacesImpl221.postInterface(nodeId,ifBuilder22); + switch (mappingUtils.getOpenRoadmVersion(nodeId)) { + case OPENROADM_DEVICE_VERSION_1_2_1: + LOG.info("postInterface for 1.2.1 device {}", nodeId); + InterfaceBuilder ifBuilder121 = convertInstanceOfInterface(ifBuilder, InterfaceBuilder.class); + openRoadmInterfacesImpl121.postInterface(nodeId,ifBuilder121); + return; + case OPENROADM_DEVICE_VERSION_2_2_1: + LOG.info("postInterface for 2.2.1 device {}", nodeId); + org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder + ifBuilder22 = convertInstanceOfInterface(ifBuilder, org.opendaylight.yang.gen.v1 + .http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder.class); + openRoadmInterfacesImpl221.postInterface(nodeId,ifBuilder22); + return; + case OPENROADM_DEVICE_VERSION_7_1_0: + LOG.info("postInterface for 7.1.0 device {}", nodeId); + org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder + ifBuilder71 = convertInstanceOfInterface(ifBuilder, org.opendaylight.yang.gen.v1 + .http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder.class); + openRoadmInterfacesImpl710.postInterface(nodeId, ifBuilder71); + return; + default: + LOG.error("postInterface unknown ordm version error device {}", nodeId); + return; } } @@ -58,16 +73,18 @@ public class OpenRoadmInterfacesImpl implements OpenRoadmInterfaces { public Optional getInterface(String nodeId, String interfaceName) throws OpenRoadmInterfaceException { String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId); - LOG.info("Interface get request received for node {} with version {}",nodeId,openRoadmVersion); - if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_1_2_1)) { - LOG.info("getInterface for 1.2.1 device {}", nodeId); - return (Optional) openRoadmInterfacesImpl121.getInterface(nodeId,interfaceName); + LOG.info("Interface get request received for node {} with version {}", nodeId, openRoadmVersion); + switch (openRoadmVersion) { + case OPENROADM_DEVICE_VERSION_1_2_1: + return (Optional) openRoadmInterfacesImpl121.getInterface(nodeId,interfaceName); + case OPENROADM_DEVICE_VERSION_2_2_1: + return (Optional) openRoadmInterfacesImpl221.getInterface(nodeId,interfaceName); + case OPENROADM_DEVICE_VERSION_7_1_0: + return (Optional) openRoadmInterfacesImpl710.getInterface(nodeId,interfaceName); + default: + LOG.error("getInterface unknown ordm version error device {}", nodeId); + return Optional.empty(); } - else if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_2_2_1)) { - LOG.info("getInterface for 2.2.1 device {}", nodeId); - return (Optional) openRoadmInterfacesImpl221.getInterface(nodeId,interfaceName); - } - return Optional.empty(); } @Override @@ -75,44 +92,90 @@ public class OpenRoadmInterfacesImpl implements OpenRoadmInterfaces { throws OpenRoadmInterfaceException { String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId); - LOG.info("Interface delete request received for node {} with version {}",nodeId,openRoadmVersion); - if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_1_2_1)) { - LOG.info("Device Version is 1.2.1"); - openRoadmInterfacesImpl121.deleteInterface(nodeId,interfaceName); - } - else if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_2_2_1)) { - openRoadmInterfacesImpl221.deleteInterface(nodeId,interfaceName); + LOG.info("Interface delete request received for node {} with version {}", nodeId, openRoadmVersion); + switch (openRoadmVersion) { + case OPENROADM_DEVICE_VERSION_1_2_1: + openRoadmInterfacesImpl121.deleteInterface(nodeId,interfaceName); + return; + case OPENROADM_DEVICE_VERSION_2_2_1: + openRoadmInterfacesImpl221.deleteInterface(nodeId,interfaceName); + return; + case OPENROADM_DEVICE_VERSION_7_1_0: + openRoadmInterfacesImpl710.deleteInterface(nodeId,interfaceName); + return; + default: + LOG.error("deleteInterface unknown ordm version error device {}", nodeId); + return; } } @Override public void postEquipmentState(String nodeId, String circuitPackName, boolean activate) throws OpenRoadmInterfaceException { - String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId); + String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId); LOG.info("Request received for node {} with version {} to change equipment-state of cp {}.", nodeId,openRoadmVersion, circuitPackName); - if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_1_2_1)) { - openRoadmInterfacesImpl121.postEquipmentState(nodeId, circuitPackName, activate); - } - else if (openRoadmVersion.equals(OPENROADM_DEVICE_VERSION_2_2_1)) { - openRoadmInterfacesImpl221.postEquipmentState(nodeId, circuitPackName, activate); + switch (openRoadmVersion) { + case OPENROADM_DEVICE_VERSION_1_2_1: + openRoadmInterfacesImpl121.postEquipmentState(nodeId, circuitPackName, activate); + return; + case OPENROADM_DEVICE_VERSION_2_2_1: + openRoadmInterfacesImpl221.postEquipmentState(nodeId, circuitPackName, activate); + return; + case OPENROADM_DEVICE_VERSION_7_1_0: + openRoadmInterfacesImpl710.postEquipmentState(nodeId, circuitPackName, activate); + return; + default: + LOG.error("postEquipmentState unknown ordm version error device {}", nodeId); + return; } - } @Override - public void postOTNInterface(String nodeId, T ifBuilder) throws OpenRoadmInterfaceException { - org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder - ifBuilder22 = (org.opendaylight.yang.gen.v1.http.org.openroadm - .device.rev181019.interfaces.grp.InterfaceBuilder) ifBuilder; - openRoadmInterfacesImpl221.postInterface(nodeId,ifBuilder22); + public void postOTNInterface(String nodeId, T ifBuilder) + throws OpenRoadmInterfaceException { + + switch (mappingUtils.getOpenRoadmVersion(nodeId)) { + case OPENROADM_DEVICE_VERSION_1_2_1: + LOG.error("postOTNInterface unsupported ordm version 1.2.1 error device {}", nodeId); + return; + case OPENROADM_DEVICE_VERSION_2_2_1: + org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder + ifBuilder22 = (org.opendaylight.yang.gen.v1 + .http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder) ifBuilder; + openRoadmInterfacesImpl221.postInterface(nodeId, ifBuilder22); + return; + case OPENROADM_DEVICE_VERSION_7_1_0: + org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder + ifBuilder71 = (org.opendaylight.yang.gen.v1 + .http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder) ifBuilder; + openRoadmInterfacesImpl710.postInterface(nodeId, ifBuilder71); + return; + default: + LOG.error("postOTNInterface unknown ordm version error device {}", nodeId); + return; + } } @Override public void postOTNEquipmentState(String nodeId, String circuitPackName, boolean activate) throws OpenRoadmInterfaceException { - openRoadmInterfacesImpl221.postEquipmentState(nodeId, circuitPackName, activate); + + switch (mappingUtils.getOpenRoadmVersion(nodeId)) { + case OPENROADM_DEVICE_VERSION_1_2_1: + LOG.error("postOTNEquipmentState unsupported ordm version 1.2.1 error device {}", nodeId); + return; + case OPENROADM_DEVICE_VERSION_2_2_1: + openRoadmInterfacesImpl221.postEquipmentState(nodeId, circuitPackName, activate); + return; + case OPENROADM_DEVICE_VERSION_7_1_0: + openRoadmInterfacesImpl710.postEquipmentState(nodeId, circuitPackName, activate); + return; + default: + LOG.error("postOTNEquipmentState unknown ordm version error device {}", nodeId); + return; + } } private T convertInstanceOfInterface(Object object, Class classToCast) { diff --git a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl710.java b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl710.java new file mode 100644 index 000000000..459baa222 --- /dev/null +++ b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl710.java @@ -0,0 +1,238 @@ +/* + * Copyright © 2020 AT&T and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.transportpce.common.openroadminterfaces; + +import com.google.common.util.concurrent.FluentFuture; +import java.util.Optional; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.mdsal.common.api.CommitInfo; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.transportpce.common.StringConstants; +import org.opendaylight.transportpce.common.Timeouts; +import org.opendaylight.transportpce.common.device.DeviceTransaction; +import org.opendaylight.transportpce.common.device.DeviceTransactionManager; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.packs.CircuitPacks; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.packs.CircuitPacksBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.packs.CircuitPacksKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.Interface; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.OrgOpenroadmDevice; +import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates; +import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.States; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.OtnOdu; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.OtnOtu; +import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.loopback.rev191129.maint.loopback.MaintLoopbackBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.testsignal.rev200529.maint.testsignal.MaintTestsignalBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.odu.container.OduBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.otu.container.OtuBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class OpenRoadmInterfacesImpl710 { + + private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfacesImpl710.class); + + private final DeviceTransactionManager deviceTransactionManager; + + public OpenRoadmInterfacesImpl710(DeviceTransactionManager deviceTransactionManager) { + this.deviceTransactionManager = deviceTransactionManager; + } + + public void postInterface(String nodeId, InterfaceBuilder ifBuilder) throws OpenRoadmInterfaceException { + Future> deviceTxFuture = deviceTransactionManager.getDeviceTransaction(nodeId); + DeviceTransaction deviceTx; + try { + Optional deviceTxOpt = deviceTxFuture.get(); + if (deviceTxOpt.isPresent()) { + deviceTx = deviceTxOpt.get(); + } else { + throw new OpenRoadmInterfaceException(String.format("Device transaction was not found for node %s!", + nodeId)); + } + } catch (InterruptedException | ExecutionException e) { + throw new OpenRoadmInterfaceException(String.format("Failed to obtain device transaction for node %s!", + nodeId), e); + } + + InstanceIdentifier interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child( + Interface.class, new InterfaceKey(ifBuilder.getName())); + LOG.info("POST INTERF for {} : InterfaceBuilder : name = {} \t type = {}", nodeId, ifBuilder.getName(), + ifBuilder.getType().toString()); + deviceTx.put(LogicalDatastoreType.CONFIGURATION, interfacesIID, ifBuilder.build()); + FluentFuture txSubmitFuture = + deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); + try { + txSubmitFuture.get(); + LOG.info("Successfully posted interface {} on node {}", ifBuilder.getName(), nodeId); + } catch (InterruptedException | ExecutionException e) { + throw new OpenRoadmInterfaceException(String.format("Failed to post interface %s on node %s!", ifBuilder + .getName(), nodeId), e); + } + } + + + public Optional getInterface(String nodeId, String interfaceName) throws OpenRoadmInterfaceException { + InstanceIdentifier interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Interface.class, new InterfaceKey(interfaceName)); + return deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.CONFIGURATION, + interfacesIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); + } + + + public void deleteInterface(String nodeId, String interfaceName) throws OpenRoadmInterfaceException { + LOG.info("deleting interface {} on device221 {}", interfaceName, nodeId); + Optional intf2DeleteOpt; + try { + intf2DeleteOpt = getInterface(nodeId, interfaceName); + } catch (OpenRoadmInterfaceException e) { + throw new OpenRoadmInterfaceException(String.format("Failed to check if interface %s exists on node %s!", + interfaceName, nodeId), e); + } + if (intf2DeleteOpt.isPresent()) { + Interface intf2Delete = intf2DeleteOpt.get(); + // State admin state to out of service + InterfaceBuilder ifBuilder = new InterfaceBuilder(intf2Delete); + if (ifBuilder.getType() == OtnOdu.class) { + Interface1Builder oduBuilder = new Interface1Builder(intf2Delete.augmentation(Interface1.class)); + OduBuilder odu = new OduBuilder(oduBuilder.getOdu()); + if (odu.getMaintTestsignal() != null) { + MaintTestsignalBuilder maintSignalBuilder = new MaintTestsignalBuilder(); + maintSignalBuilder.setEnabled(false); + odu.setMaintTestsignal(maintSignalBuilder.build()); + } + oduBuilder.setOdu(odu.build()); + ifBuilder.addAugmentation(oduBuilder.build()); + } else if (ifBuilder.getType() == OtnOtu.class) { + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder + otuBuilder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder( + intf2Delete.augmentation( + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1 + .class)); + OtuBuilder otu = new OtuBuilder(otuBuilder.getOtu()); + if (otu.getMaintLoopback() != null) { + MaintLoopbackBuilder maintLoopBackBuilder = new MaintLoopbackBuilder(); + maintLoopBackBuilder.setEnabled(false); + otu.setMaintLoopback(maintLoopBackBuilder.build()); + } + otuBuilder.setOtu(otu.build()); + ifBuilder.addAugmentation(otuBuilder.build()); + } + ifBuilder.setAdministrativeState(AdminStates.OutOfService); + // post interface with updated admin state + try { + postInterface(nodeId, ifBuilder); + } catch (OpenRoadmInterfaceException ex) { + throw new OpenRoadmInterfaceException(String.format("Failed to set state of interface %s to %s while" + + " deleting it!", interfaceName, AdminStates.OutOfService), ex); + } + + InstanceIdentifier interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child( + Interface.class, new InterfaceKey(interfaceName)); + Future> deviceTxFuture = this.deviceTransactionManager.getDeviceTransaction( + nodeId); + DeviceTransaction deviceTx; + try { + Optional deviceTxOpt = deviceTxFuture.get(); + if (deviceTxOpt.isPresent()) { + deviceTx = deviceTxOpt.get(); + } else { + throw new OpenRoadmInterfaceException(String.format("Device transaction was not found for node %s!", + nodeId)); + } + } catch (InterruptedException | ExecutionException e) { + throw new OpenRoadmInterfaceException(String.format("Failed to obtain device transaction for node %s!", + nodeId), e); + } + + deviceTx.delete(LogicalDatastoreType.CONFIGURATION, interfacesIID); + FluentFuture commit = + deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); + + try { + commit.get(); + LOG.info("Successfully deleted {} on node {}", interfaceName, nodeId); + } catch (InterruptedException | ExecutionException e) { + throw new OpenRoadmInterfaceException(String.format("Failed to delete interface %s on " + "node %s", + interfaceName, nodeId), e); + } + // change the equipment state on circuit pack if xpdr node + if (intf2Delete.getName().contains(StringConstants.CLIENT_TOKEN) || intf2Delete.getName().contains( + StringConstants.NETWORK_TOKEN)) { + postEquipmentState(nodeId, intf2Delete.getSupportingCircuitPackName(), false); + } + + } else { + LOG.info("Interface does not exist, cannot delete on node {}", nodeId); + } + } + + public void postEquipmentState(String nodeId, String circuitPackName, boolean activate) + throws OpenRoadmInterfaceException { + InstanceIdentifier circuitPackIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child( + CircuitPacks.class, new CircuitPacksKey(circuitPackName)); + Optional cpOpt = this.deviceTransactionManager.getDataFromDevice(nodeId, + LogicalDatastoreType.CONFIGURATION, circuitPackIID, Timeouts.DEVICE_READ_TIMEOUT, + Timeouts.DEVICE_READ_TIMEOUT_UNIT); + CircuitPacks cp = null; + if (cpOpt.isPresent()) { + cp = cpOpt.get(); + } else { + throw new OpenRoadmInterfaceException(String.format( + "Could not find CircuitPack %s in equipment config datastore for node %s", circuitPackName, nodeId)); + } + CircuitPacksBuilder cpBldr = new CircuitPacksBuilder(cp); + boolean change = false; + if (activate) { + if (cpBldr.getEquipmentState() != null + && !States.NotReservedInuse.equals(cpBldr.getEquipmentState())) { + cpBldr.setEquipmentState(States.NotReservedInuse); + change = true; + } + } else if ((cpBldr.getEquipmentState() != null + && !States.NotReservedAvailable.equals(cpBldr.getEquipmentState()))) { + cpBldr.setEquipmentState(States.NotReservedAvailable); + change = true; + } + if (change) { + Future> deviceTxFuture = this.deviceTransactionManager.getDeviceTransaction( + nodeId); + DeviceTransaction deviceTx; + try { + Optional deviceTxOpt = deviceTxFuture.get(); + if (deviceTxOpt.isPresent()) { + deviceTx = deviceTxOpt.get(); + } else { + throw new OpenRoadmInterfaceException(String.format("Device transaction was not found for node %s!", + nodeId)); + } + } catch (InterruptedException | ExecutionException e) { + throw new OpenRoadmInterfaceException(String.format("Failed to obtain device transaction for node %s!", + nodeId), e); + } + deviceTx.put(LogicalDatastoreType.CONFIGURATION, circuitPackIID, cpBldr.build()); + FluentFuture txSubmitFuture = + deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); + try { + txSubmitFuture.get(); + LOG.info("Successfully posted equipment state change on node {}", nodeId); + } catch (InterruptedException | ExecutionException e) { + throw new OpenRoadmInterfaceException(String.format("Failed to post equipment state on node %s!", + nodeId), e); + } + } + } + +} diff --git a/common/src/main/resources/OSGI-INF/blueprint/common-blueprint.xml b/common/src/main/resources/OSGI-INF/blueprint/common-blueprint.xml index c44e120e3..9e4fde947 100644 --- a/common/src/main/resources/OSGI-INF/blueprint/common-blueprint.xml +++ b/common/src/main/resources/OSGI-INF/blueprint/common-blueprint.xml @@ -32,11 +32,22 @@ and is available at http://www.eclipse.org/legal/epl-v10.html + + + + + + + + + + + @@ -45,6 +56,12 @@ and is available at http://www.eclipse.org/legal/epl-v10.html + + + + + + @@ -53,16 +70,11 @@ and is available at http://www.eclipse.org/legal/epl-v10.html - - - - - - + diff --git a/common/src/test/java/org/opendaylight/transportpce/common/mapping/PortMappingImplTest.java b/common/src/test/java/org/opendaylight/transportpce/common/mapping/PortMappingImplTest.java index 0457c2c83..fa5c68e6f 100644 --- a/common/src/test/java/org/opendaylight/transportpce/common/mapping/PortMappingImplTest.java +++ b/common/src/test/java/org/opendaylight/transportpce/common/mapping/PortMappingImplTest.java @@ -40,6 +40,7 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; public class PortMappingImplTest { DataBroker dataBroker = null; + private PortMappingVersion710 portMappingVersion710; private PortMappingVersion221 portMappingVersion221; private PortMappingVersion121 portMappingVersion121; private PortMapping portMapping; @@ -48,9 +49,11 @@ public class PortMappingImplTest { public void setUp() throws Exception { DataStoreContext dataStoreContext = new DataStoreContextImpl(); dataBroker = dataStoreContext.getDataBroker(); + portMappingVersion710 = mock(PortMappingVersion710.class); portMappingVersion221 = mock(PortMappingVersion221.class); portMappingVersion121 = mock(PortMappingVersion121.class); - portMapping = new PortMappingImpl(dataBroker, portMappingVersion221, portMappingVersion121); + portMapping = new PortMappingImpl(dataBroker, portMappingVersion710, + portMappingVersion221, portMappingVersion121); } @Test diff --git a/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java b/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java index eb40d2035..efa1ef2e2 100644 --- a/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java +++ b/lighty/src/main/java/io/lighty/controllers/tpce/module/TransportPCEImpl.java @@ -22,6 +22,7 @@ import org.opendaylight.transportpce.common.mapping.PortMapping; import org.opendaylight.transportpce.common.mapping.PortMappingImpl; import org.opendaylight.transportpce.common.mapping.PortMappingVersion121; import org.opendaylight.transportpce.common.mapping.PortMappingVersion221; +import org.opendaylight.transportpce.common.mapping.PortMappingVersion710; import org.opendaylight.transportpce.common.network.NetworkTransactionImpl; import org.opendaylight.transportpce.common.network.NetworkTransactionService; import org.opendaylight.transportpce.common.network.RequestProcessor; @@ -29,6 +30,7 @@ import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfa import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710; import org.opendaylight.transportpce.networkmodel.NetConfTopologyListener; import org.opendaylight.transportpce.networkmodel.NetworkModelProvider; import org.opendaylight.transportpce.networkmodel.NetworkUtilsImpl; @@ -273,11 +275,14 @@ public class TransportPCEImpl extends AbstractLightyModule implements TransportP * @return PortMapping instance */ private PortMapping initPortMapping(LightyServices lightyServices, OpenRoadmInterfaces openRoadmInterfaces) { + PortMappingVersion710 portMappingVersion710 = new PortMappingVersion710(lightyServices.getBindingDataBroker(), + deviceTransactionManager, openRoadmInterfaces); PortMappingVersion221 portMappingVersion221 = new PortMappingVersion221(lightyServices.getBindingDataBroker(), deviceTransactionManager, openRoadmInterfaces); PortMappingVersion121 portMappingVersion121 = new PortMappingVersion121(lightyServices.getBindingDataBroker(), deviceTransactionManager, openRoadmInterfaces); - return new PortMappingImpl(lightyServices.getBindingDataBroker(), portMappingVersion221, portMappingVersion121); + return new PortMappingImpl(lightyServices.getBindingDataBroker(), portMappingVersion710, + portMappingVersion221, portMappingVersion121); } /** @@ -291,8 +296,10 @@ public class TransportPCEImpl extends AbstractLightyModule implements TransportP deviceTransactionManager); OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221 = new OpenRoadmInterfacesImpl221( deviceTransactionManager); + OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710( + deviceTransactionManager); return new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils, openRoadmInterfacesImpl121, - openRoadmInterfacesImpl221); + openRoadmInterfacesImpl221, openRoadmInterfacesImpl710); } /** diff --git a/lighty/src/main/java/io/lighty/controllers/tpce/utils/TPCEUtils.java b/lighty/src/main/java/io/lighty/controllers/tpce/utils/TPCEUtils.java index 0f5e0febf..62eeea320 100644 --- a/lighty/src/main/java/io/lighty/controllers/tpce/utils/TPCEUtils.java +++ b/lighty/src/main/java/io/lighty/controllers/tpce/utils/TPCEUtils.java @@ -33,12 +33,15 @@ public final class TPCEUtils { .getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev181130.$YangModuleInfoImpl .getInstance(), + org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.$YangModuleInfoImpl + .getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev181130.$YangModuleInfoImpl .getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.$YangModuleInfoImpl.getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev170929.$YangModuleInfoImpl.getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.$YangModuleInfoImpl.getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181130.$YangModuleInfoImpl.getInstance(), + org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.$YangModuleInfoImpl.getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev161014.$YangModuleInfoImpl .getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev171215.$YangModuleInfoImpl @@ -61,6 +64,7 @@ public final class TPCEUtils { org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev170929.$YangModuleInfoImpl.getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev181019.$YangModuleInfoImpl.getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev181130.$YangModuleInfoImpl.getInstance(), + org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.$YangModuleInfoImpl.getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.probablecause.rev161014.$YangModuleInfoImpl.getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.probablecause.rev181019.$YangModuleInfoImpl.getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.$YangModuleInfoImpl.getInstance(), @@ -71,6 +75,8 @@ public final class TPCEUtils { .getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.switching.pool.types.rev181130.$YangModuleInfoImpl .getInstance(), + org.opendaylight.yang.gen.v1.http.org.openroadm.switching.pool.types.rev191129.$YangModuleInfoImpl + .getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.tca.rev161014.$YangModuleInfoImpl.getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.tca.rev181019.$YangModuleInfoImpl.getInstance(), org.opendaylight.yang.gen.v1.http.org.openroadm.user.mgmt.rev161014.$YangModuleInfoImpl.getInstance(), diff --git a/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/NetConfTopologyListenerTest.java b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/NetConfTopologyListenerTest.java index ceec23794..6d8a0fd12 100644 --- a/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/NetConfTopologyListenerTest.java +++ b/networkmodel/src/test/java/org/opendaylight/transportpce/networkmodel/NetConfTopologyListenerTest.java @@ -34,12 +34,14 @@ import org.opendaylight.transportpce.common.mapping.PortMapping; import org.opendaylight.transportpce.common.mapping.PortMappingImpl; import org.opendaylight.transportpce.common.mapping.PortMappingVersion121; import org.opendaylight.transportpce.common.mapping.PortMappingVersion221; +import org.opendaylight.transportpce.common.mapping.PortMappingVersion710; import org.opendaylight.transportpce.common.network.NetworkTransactionImpl; import org.opendaylight.transportpce.common.network.NetworkTransactionService; import org.opendaylight.transportpce.common.network.RequestProcessor; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710; import org.opendaylight.transportpce.networkmodel.service.NetworkModelService; import org.opendaylight.transportpce.networkmodel.stub.MountPointServiceStub; import org.opendaylight.transportpce.networkmodel.stub.MountPointStub; @@ -93,13 +95,16 @@ public class NetConfTopologyListenerTest { new OpenRoadmInterfacesImpl121(deviceTransactionManager); OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221 = new OpenRoadmInterfacesImpl221(deviceTransactionManager); + OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710 = + new OpenRoadmInterfacesImpl710(deviceTransactionManager); MappingUtils mappingUtils = new MappingUtilsImpl(dataBroker); OpenRoadmInterfacesImpl openRoadmInterfaces = new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils, - openRoadmInterfacesImpl121, openRoadmInterfacesImpl221); + openRoadmInterfacesImpl121, openRoadmInterfacesImpl221, openRoadmInterfacesImpl710); PortMappingVersion121 p1 = new PortMappingVersion121(dataBroker, deviceTransactionManager, openRoadmInterfaces); PortMappingVersion221 p2 = new PortMappingVersion221(dataBroker, deviceTransactionManager, openRoadmInterfaces); - PortMapping portMapping = new PortMappingImpl(dataBroker, p2, p1); + PortMappingVersion710 p3 = new PortMappingVersion710(dataBroker, deviceTransactionManager, openRoadmInterfaces); + PortMapping portMapping = new PortMappingImpl(dataBroker,p3, p2, p1); NetworkModelService networkModelService = mock(NetworkModelService.class); //Start Netconf Topology listener and start adding nodes to the Netconf Topology to verify behaviour diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImplTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImplTest.java index bd7696a27..656418772 100644 --- a/olm/src/test/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImplTest.java +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImplTest.java @@ -34,10 +34,12 @@ import org.opendaylight.transportpce.common.mapping.PortMapping; import org.opendaylight.transportpce.common.mapping.PortMappingImpl; import org.opendaylight.transportpce.common.mapping.PortMappingVersion121; import org.opendaylight.transportpce.common.mapping.PortMappingVersion221; +import org.opendaylight.transportpce.common.mapping.PortMappingVersion710; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710; import org.opendaylight.transportpce.olm.power.PowerMgmt; import org.opendaylight.transportpce.olm.power.PowerMgmtImpl; import org.opendaylight.transportpce.olm.service.OlmPowerService; @@ -92,6 +94,8 @@ public class OlmPowerServiceRpcImplTest extends AbstractTest { private MappingUtils mappingUtils; private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl22; + private OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710; + private PortMappingVersion710 portMappingVersion710; private PortMappingVersion221 portMappingVersion22; private PortMappingVersion121 portMappingVersion121; @@ -110,13 +114,18 @@ public class OlmPowerServiceRpcImplTest extends AbstractTest { this.crossConnectImpl22); this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager); this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager); + this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager); this.openRoadmInterfaces = new OpenRoadmInterfacesImpl((this.deviceTransactionManager), - this.mappingUtils,this.openRoadmInterfacesImpl121,this.openRoadmInterfacesImpl22); + this.mappingUtils,this.openRoadmInterfacesImpl121,this.openRoadmInterfacesImpl22, + this.openRoadmInterfacesImpl710); + this.portMappingVersion710 = + new PortMappingVersion710(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); this.portMappingVersion22 = new PortMappingVersion221(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); this.portMappingVersion121 = new PortMappingVersion121(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); - this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion22, this.portMappingVersion121); + this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion710, + this.portMappingVersion22, this.portMappingVersion121); this.portMapping = Mockito.spy(this.portMapping); this.powerMgmt = new PowerMgmtImpl(this.getDataBroker(), this.openRoadmInterfaces, this.crossConnect, this.deviceTransactionManager); diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtPowerMockTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtPowerMockTest.java index 6310668cf..91638d623 100644 --- a/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtPowerMockTest.java +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtPowerMockTest.java @@ -34,11 +34,13 @@ import org.opendaylight.transportpce.common.mapping.PortMapping; import org.opendaylight.transportpce.common.mapping.PortMappingImpl; import org.opendaylight.transportpce.common.mapping.PortMappingVersion121; import org.opendaylight.transportpce.common.mapping.PortMappingVersion221; +import org.opendaylight.transportpce.common.mapping.PortMappingVersion710; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710; import org.opendaylight.transportpce.olm.stub.MountPointServiceStub; import org.opendaylight.transportpce.olm.stub.MountPointStub; import org.opendaylight.transportpce.olm.util.OlmPowerServiceRpcImplUtil; @@ -85,6 +87,8 @@ public class PowerMgmtPowerMockTest extends AbstractTest { private MappingUtils mappingUtils; private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl22; + private OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710; + private PortMappingVersion710 portMappingVersion710; private PortMappingVersion221 portMappingVersion22; private PortMappingVersion121 portMappingVersion121; @@ -103,14 +107,19 @@ public class PowerMgmtPowerMockTest extends AbstractTest { this.crossConnectImpl22); this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager); this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager); + this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager); this.openRoadmInterfaces = new OpenRoadmInterfacesImpl((this.deviceTransactionManager), - this.mappingUtils,this.openRoadmInterfacesImpl121,this.openRoadmInterfacesImpl22); + this.mappingUtils,this.openRoadmInterfacesImpl121,this.openRoadmInterfacesImpl22, + this.openRoadmInterfacesImpl710); this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces); this.portMappingVersion22 = new PortMappingVersion221(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); this.portMappingVersion121 = new PortMappingVersion121(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); - this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion22, this.portMappingVersion121); + this.portMappingVersion710 = + new PortMappingVersion710(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); + this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion710, + this.portMappingVersion22, this.portMappingVersion121); this.portMapping = Mockito.spy(this.portMapping); this.powerMgmt = new PowerMgmtImpl(this.getDataBroker(), this.openRoadmInterfaces, this.crossConnect, this.deviceTransactionManager); @@ -233,7 +242,8 @@ public class PowerMgmtPowerMockTest extends AbstractTest { private PowerMgmtImpl getNewPowerMgmt(OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121Spy, CrossConnect crossConnectMock) { OpenRoadmInterfacesImpl openRoadmInterfacesSpy = new OpenRoadmInterfacesImpl((this.deviceTransactionManager), - this.mappingUtils, openRoadmInterfacesImpl121Spy, this.openRoadmInterfacesImpl22); + this.mappingUtils, openRoadmInterfacesImpl121Spy, this.openRoadmInterfacesImpl22, + this.openRoadmInterfacesImpl710); openRoadmInterfacesSpy = PowerMockito.spy(openRoadmInterfacesSpy); return new PowerMgmtImpl(this.getDataBroker(), openRoadmInterfacesSpy, crossConnectMock, this.deviceTransactionManager); diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtTest.java index 21ffdcfba..db22852fb 100644 --- a/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtTest.java +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtTest.java @@ -29,10 +29,12 @@ import org.opendaylight.transportpce.common.mapping.PortMapping; import org.opendaylight.transportpce.common.mapping.PortMappingImpl; import org.opendaylight.transportpce.common.mapping.PortMappingVersion121; import org.opendaylight.transportpce.common.mapping.PortMappingVersion221; +import org.opendaylight.transportpce.common.mapping.PortMappingVersion710; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710; import org.opendaylight.transportpce.olm.stub.MountPointServiceStub; import org.opendaylight.transportpce.olm.stub.MountPointStub; import org.opendaylight.transportpce.olm.util.OlmPowerServiceRpcImplUtil; @@ -55,6 +57,8 @@ public class PowerMgmtTest extends AbstractTest { private MappingUtils mappingUtils; private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl22; + private OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710; + private PortMappingVersion710 portMappingVersion710; private PortMappingVersion221 portMappingVersion22; private PortMappingVersion121 portMappingVersion121; private DataBroker dataBroker; @@ -75,14 +79,16 @@ public class PowerMgmtTest extends AbstractTest { this.crossConnectImpl22); this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager); this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager); + this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager); this.openRoadmInterfaces = new OpenRoadmInterfacesImpl((this.deviceTransactionManager), - this.mappingUtils,this.openRoadmInterfacesImpl121,this.openRoadmInterfacesImpl22); + this.mappingUtils,this.openRoadmInterfacesImpl121,this.openRoadmInterfacesImpl22, + this.openRoadmInterfacesImpl710); this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces); this.portMappingVersion22 = new PortMappingVersion221(dataBroker, deviceTransactionManager, this.openRoadmInterfaces); this.portMappingVersion121 = new PortMappingVersion121(dataBroker, deviceTransactionManager, this.openRoadmInterfaces); - this.portMapping = new PortMappingImpl(dataBroker, + this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion710, this.portMappingVersion22, this.portMappingVersion121); this.portMapping = Mockito.spy(this.portMapping); this.powerMgmt = new PowerMgmtImpl(this.dataBroker, this.openRoadmInterfaces, this.crossConnect, diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplSpanLossBaseTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplSpanLossBaseTest.java index 902dd2cc7..2083190ee 100644 --- a/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplSpanLossBaseTest.java +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplSpanLossBaseTest.java @@ -31,6 +31,7 @@ import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfa import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710; import org.opendaylight.transportpce.olm.power.PowerMgmt; import org.opendaylight.transportpce.olm.power.PowerMgmtImpl; import org.opendaylight.transportpce.olm.util.OlmPowerServiceRpcImplUtil; @@ -67,6 +68,7 @@ public class OlmPowerServiceImplSpanLossBaseTest extends AbstractTest { private MappingUtils mappingUtils; private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221; private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; + private OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710; private OlmPowerService olmPowerService; private DataBroker dataBroker; @@ -79,7 +81,7 @@ public class OlmPowerServiceImplSpanLossBaseTest extends AbstractTest { this.deviceTransactionManager = Mockito.mock(DeviceTransactionManagerImpl.class); this.powerMgmt = Mockito.mock(PowerMgmtImpl.class); this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(this.deviceTransactionManager, this.mappingUtils, - this.openRoadmInterfacesImpl121, this.openRoadmInterfacesImpl221); + this.openRoadmInterfacesImpl121, this.openRoadmInterfacesImpl221, this.openRoadmInterfacesImpl710); this.olmPowerService = new OlmPowerServiceImpl(this.getDataBroker(), this.powerMgmt, this.deviceTransactionManager, this.portMapping, this.mappingUtils, this.openRoadmInterfaces); this.dataBroker = this.getDataBroker(); diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplTest.java index 78d4c01b9..cbfe928eb 100644 --- a/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplTest.java +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplTest.java @@ -32,10 +32,12 @@ import org.opendaylight.transportpce.common.mapping.PortMapping; import org.opendaylight.transportpce.common.mapping.PortMappingImpl; import org.opendaylight.transportpce.common.mapping.PortMappingVersion121; import org.opendaylight.transportpce.common.mapping.PortMappingVersion221; +import org.opendaylight.transportpce.common.mapping.PortMappingVersion710; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710; import org.opendaylight.transportpce.olm.power.PowerMgmt; import org.opendaylight.transportpce.olm.power.PowerMgmtImpl; import org.opendaylight.transportpce.olm.stub.MountPointServiceStub; @@ -85,6 +87,8 @@ public class OlmPowerServiceImplTest extends AbstractTest { private MappingUtils mappingUtils; private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl22; + private OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710; + private PortMappingVersion710 portMappingVersion710; private PortMappingVersion221 portMappingVersion22; private PortMappingVersion121 portMappingVersion121; private OlmPowerService olmPowerService; @@ -111,13 +115,18 @@ public class OlmPowerServiceImplTest extends AbstractTest { this.crossConnectImpl22); this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager); this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager); + this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager); this.openRoadmInterfaces = new OpenRoadmInterfacesImpl((this.deviceTransactionManager), - this.mappingUtils,this.openRoadmInterfacesImpl121,this.openRoadmInterfacesImpl22); + this.mappingUtils,this.openRoadmInterfacesImpl121,this.openRoadmInterfacesImpl22, + this.openRoadmInterfacesImpl710); this.portMappingVersion22 = new PortMappingVersion221(dataBroker, deviceTransactionManager, this.openRoadmInterfaces); this.portMappingVersion121 = new PortMappingVersion121(dataBroker, deviceTransactionManager, this.openRoadmInterfaces); - this.portMapping = new PortMappingImpl(dataBroker, this.portMappingVersion22, this.portMappingVersion121); + this.portMappingVersion710 = + new PortMappingVersion710(dataBroker, deviceTransactionManager, this.openRoadmInterfaces); + this.portMapping = new PortMappingImpl(dataBroker, this.portMappingVersion710, + this.portMappingVersion22, this.portMappingVersion121); this.portMapping = Mockito.spy(this.portMapping); this.powerMgmt = new PowerMgmtImpl(this.dataBroker, this.openRoadmInterfaces, this.crossConnect, this.deviceTransactionManager); diff --git a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplCreateOtsOmsTest.java b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplCreateOtsOmsTest.java index 420b5371e..465a8c03a 100644 --- a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplCreateOtsOmsTest.java +++ b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImplCreateOtsOmsTest.java @@ -34,11 +34,13 @@ import org.opendaylight.transportpce.common.mapping.PortMapping; import org.opendaylight.transportpce.common.mapping.PortMappingImpl; import org.opendaylight.transportpce.common.mapping.PortMappingVersion121; import org.opendaylight.transportpce.common.mapping.PortMappingVersion221; +import org.opendaylight.transportpce.common.mapping.PortMappingVersion710; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface221; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; @@ -68,6 +70,8 @@ public class DeviceRendererServiceImplCreateOtsOmsTest extends AbstractTest { private MappingUtils mappingUtils; private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221; + private OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710; + private PortMappingVersion710 portMappingVersion710; private PortMappingVersion221 portMappingVersion22; private PortMappingVersion121 portMappingVersion121; private CrossConnectImpl121 crossConnectImpl121; @@ -78,20 +82,24 @@ public class DeviceRendererServiceImplCreateOtsOmsTest extends AbstractTest { this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000); this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(this.deviceTransactionManager); this.openRoadmInterfacesImpl221 = new OpenRoadmInterfacesImpl221(this.deviceTransactionManager); + this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(this.deviceTransactionManager); this.mappingUtils = new MappingUtilsImpl(getDataBroker()); this.mappingUtils = Mockito.spy(MappingUtils.class); Mockito.doReturn(StringConstants.OPENROADM_DEVICE_VERSION_1_2_1).when(mappingUtils) .getOpenRoadmVersion(Mockito.anyString()); this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils, - openRoadmInterfacesImpl121, openRoadmInterfacesImpl221); + openRoadmInterfacesImpl121, openRoadmInterfacesImpl221, openRoadmInterfacesImpl710); this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces); this.portMappingVersion22 = new PortMappingVersion221(getDataBroker(), this.deviceTransactionManager, this.openRoadmInterfaces); this.portMappingVersion121 = new PortMappingVersion121(getDataBroker(), this.deviceTransactionManager, this.openRoadmInterfaces); - PortMapping portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion22, - this.portMappingVersion121); + this.portMappingVersion710 = + new PortMappingVersion710(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); + PortMapping portMapping = + new PortMappingImpl(getDataBroker(), this.portMappingVersion710, this.portMappingVersion22, + this.portMappingVersion121); FixedFlexInterface fixedFlexInterface = new FixedFlexImpl(); FlexGridImpl flexGrid = new FlexGridImpl(); OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces); diff --git a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplDeleteTest.java b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplDeleteTest.java index cfb1ca260..2f8da5659 100644 --- a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplDeleteTest.java +++ b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplDeleteTest.java @@ -40,10 +40,12 @@ import org.opendaylight.transportpce.common.mapping.PortMapping; import org.opendaylight.transportpce.common.mapping.PortMappingImpl; import org.opendaylight.transportpce.common.mapping.PortMappingVersion121; import org.opendaylight.transportpce.common.mapping.PortMappingVersion221; +import org.opendaylight.transportpce.common.mapping.PortMappingVersion710; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710; import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService; import org.opendaylight.transportpce.renderer.NetworkModelWavelengthServiceImpl; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121; @@ -91,6 +93,8 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest { private MappingUtils mappingUtils; private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221; + private OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710; + private PortMappingVersion710 portMappingVersion710; private PortMappingVersion221 portMappingVersion22; private PortMappingVersion121 portMappingVersion121; private CrossConnectImpl121 crossConnectImpl121; @@ -102,15 +106,18 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest { this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000); this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager); this.openRoadmInterfacesImpl221 = new OpenRoadmInterfacesImpl221(deviceTransactionManager); + this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager); this.mappingUtils = new MappingUtilsImpl(getDataBroker()); this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils, - openRoadmInterfacesImpl121, openRoadmInterfacesImpl221); + openRoadmInterfacesImpl121, openRoadmInterfacesImpl221, openRoadmInterfacesImpl710); this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces); + this.portMappingVersion710 = + new PortMappingVersion710(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); this.portMappingVersion22 = new PortMappingVersion221(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); this.portMappingVersion121 = new PortMappingVersion121(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); - this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion22, + this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion710, this.portMappingVersion22, this.portMappingVersion121); this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager); this.crossConnectImpl221 = new CrossConnectImpl221(deviceTransactionManager); diff --git a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplTest.java b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplTest.java index 214eaaea2..4d6bb11cc 100644 --- a/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplTest.java +++ b/renderer/src/test/java/org/opendaylight/transportpce/renderer/provisiondevice/RendererServiceOperationsImplTest.java @@ -35,11 +35,13 @@ import org.opendaylight.transportpce.common.mapping.PortMapping; import org.opendaylight.transportpce.common.mapping.PortMappingImpl; import org.opendaylight.transportpce.common.mapping.PortMappingVersion121; import org.opendaylight.transportpce.common.mapping.PortMappingVersion221; +import org.opendaylight.transportpce.common.mapping.PortMappingVersion710; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl710; import org.opendaylight.transportpce.renderer.NetworkModelWavelengthService; import org.opendaylight.transportpce.renderer.NetworkModelWavelengthServiceImpl; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121; @@ -85,6 +87,8 @@ public class RendererServiceOperationsImplTest extends AbstractTest { private MappingUtils mappingUtils; private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221; + private OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710; + private PortMappingVersion710 portMappingVersion710; private PortMappingVersion221 portMappingVersion22; private PortMappingVersion121 portMappingVersion121; private CrossConnectImpl121 crossConnectImpl121; @@ -95,15 +99,18 @@ public class RendererServiceOperationsImplTest extends AbstractTest { this.deviceTransactionManager = new DeviceTransactionManagerImpl(this.mountPointService, 3000); this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager); this.openRoadmInterfacesImpl221 = new OpenRoadmInterfacesImpl221(deviceTransactionManager); + this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager); this.mappingUtils = new MappingUtilsImpl(getDataBroker()); this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(deviceTransactionManager, mappingUtils, - openRoadmInterfacesImpl121, openRoadmInterfacesImpl221); + openRoadmInterfacesImpl121, openRoadmInterfacesImpl221, openRoadmInterfacesImpl710); this.openRoadmInterfaces = Mockito.spy(this.openRoadmInterfaces); this.portMappingVersion22 = new PortMappingVersion221(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); this.portMappingVersion121 = new PortMappingVersion121(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); - this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion22, + this.portMappingVersion710 = + new PortMappingVersion710(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces); + this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion710, this.portMappingVersion22, this.portMappingVersion121); FixedFlexInterface fixedFlexInterface = new FixedFlexImpl(); FlexGridImpl flexGrid = new FlexGridImpl(); -- 2.36.6