From 08fd8ea395fe53fb00dec92e4113903c0821da4f Mon Sep 17 00:00:00 2001 From: Balagangadhar Bathula Date: Wed, 24 Feb 2021 10:07:47 -0500 Subject: [PATCH] Device Renderer to support transponder for B100G - Addition of OpenRoadm interfaces for 7.1.0 model - Modification to OpenRoadm interface factory - Modify the JUnit tests, Lighty and OSGi resources to support this change JIRA: TRNSPRTPCE-258 Change-Id: I896eb3d3dd958afba7186335207cf385d8ec8034 Signed-off-by: Balagangadhar Bathula Signed-off-by: guillaume.lambert --- .../tpce/module/TransportPCEImpl.java | 4 +- .../OpenRoadmInterface710.java | 602 ++++++++++++++++++ .../OpenRoadmInterfaceFactory.java | 33 +- .../OSGI-INF/blueprint/renderer-blueprint.xml | 7 + ...ceRendererServiceImplCreateOtsOmsTest.java | 4 +- ...ndererServiceOperationsImplDeleteTest.java | 4 +- .../RendererServiceOperationsImplTest.java | 4 +- 7 files changed, 652 insertions(+), 6 deletions(-) create mode 100644 renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java 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 fe1c59fa6..df72b07f1 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 @@ -51,6 +51,7 @@ import org.opendaylight.transportpce.pce.service.PathComputationServiceImpl; import org.opendaylight.transportpce.renderer.RendererProvider; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface121; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface221; +import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface710; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; // Adding OTN interface import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221; @@ -259,10 +260,11 @@ public class TransportPCEImpl extends AbstractLightyModule implements TransportP OpenRoadmInterfaces openRoadmInterfaces, PortMapping portMapping) { OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping, openRoadmInterfaces); OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping, openRoadmInterfaces); + OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping, openRoadmInterfaces); OpenRoadmOtnInterface221 openRoadmOtnInterface221 = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces); return new OpenRoadmInterfaceFactory(mappingUtils, openRoadmInterface121, openRoadmInterface221, - openRoadmOtnInterface221); + openRoadmInterface710, openRoadmOtnInterface221); } /** diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java new file mode 100644 index 000000000..38897a4db --- /dev/null +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java @@ -0,0 +1,602 @@ +/* + * Copyright © 2021 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.renderer.openroadminterface; + +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import java.util.stream.IntStream; +import org.opendaylight.transportpce.common.StringConstants; +import org.opendaylight.transportpce.common.fixedflex.GridConstant; +import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation; +import org.opendaylight.transportpce.common.mapping.PortMapping; +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.nodes.Mapping; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.TrailTraceOther.TimDetectMode; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.parent.odu.allocation.ParentOduAllocationBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.parent.odu.allocation.parent.odu.allocation.trib.slots.choice.OpucnBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.link.types.rev191129.PowerDBm; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.Foic48; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyTHz; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.ModulationFormat; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.ProvisionModeType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.R400GOtsi; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev200529.Ofec; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev200529.Rsfec; +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.equipment.states.types.rev191129.AdminStates; +import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev200529.Interface1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev200529.ethernet.container.EthernetBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.EthernetCsmacd; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.InterfaceType; +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.interfaces.rev191129.Otsi; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.OtsiGroup; +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.optical.channel.tributary.signal.interfaces.rev200529.otsi.attributes.FlexoBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.otsi.container.OtsiBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUCn; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUTTP; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUTTPCTP; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUflexCbr; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUflexCbr400G; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OTUCn; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.PayloadTypeDef; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.OduAttributes.MonitoringMode; +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.odu.interfaces.rev200529.opu.OpuBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.otu.container.OtuBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otsi.group.interfaces.rev200529.otsi.group.container.OtsiGroupBuilder; +import org.opendaylight.yangtools.yang.common.Uint16; +import org.opendaylight.yangtools.yang.common.Uint32; +import org.opendaylight.yangtools.yang.common.Uint8; + + +public class OpenRoadmInterface710 { + private static final String MAPPING_ERROR_EXCEPTION_MESSAGE = + "Unable to get mapping from PortMapping for node % and logical connection port %s"; + private final PortMapping portMapping; + private final OpenRoadmInterfaces openRoadmInterfaces; + + + public OpenRoadmInterface710(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) { + this.portMapping = portMapping; + this.openRoadmInterfaces = openRoadmInterfaces; + } + + public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint) + throws OpenRoadmInterfaceException { + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint)); + } + + // Ethernet interface specific data + EthernetBuilder ethIfBuilder = new EthernetBuilder() + .setFec(Rsfec.class) + .setSpeed(Uint32.valueOf(400000)); + + InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.class, + logicalConnPoint + "-ETHERNET"); + // Create Interface1 type object required for adding as augmentation + Interface1Builder ethIf1Builder = new Interface1Builder(); + ethInterfaceBldr.addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr); + + // Post the equipment-state change on the device circuit-pack + openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true); + + return ethInterfaceBldr.getName(); + } + + + public String createOpenRoadmOtsiInterface(String nodeId, String logicalConnPoint, + SpectrumInformation spectrumInformation) + throws OpenRoadmInterfaceException { + // TODO : Check this method + ModulationFormat modulationFormat = ModulationFormat.DpQam16; + Optional optionalModulationFormat = ModulationFormat + .forName(spectrumInformation.getModulationFormat()); + if (optionalModulationFormat.isPresent()) { + modulationFormat = optionalModulationFormat.get(); + } + // Set the Flexo values + FlexoBuilder flexoBuilder = new FlexoBuilder() + .setFoicType(Foic48.class) + .setIid(new ArrayList<>(Arrays.asList(Uint8.valueOf(1), Uint8.valueOf(2), + Uint8.valueOf(3), Uint8.valueOf(4)))); + + // OTSI interface specific data + OtsiBuilder otsiBuilder = new OtsiBuilder() + .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency())) + .setTransmitPower(new PowerDBm(new BigDecimal("-5"))) + .setModulationFormat(modulationFormat) + .setOtsiRate(R400GOtsi.class) + .setProvisionMode(ProvisionModeType.Explicit) + .setFec(Ofec.class) + .setFlexo(flexoBuilder.build()); + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint)); + } + // Create generic interface + InterfaceBuilder otsiInterfaceBldr = createGenericInterfaceBuilder(portMap, Otsi.class, + spectrumInformation.getIdentifierFromParams(logicalConnPoint)); + + // Create Interface1 type object required for adding as augmentation + org.opendaylight.yang.gen.v1.http + .org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.Interface1Builder otsiIf1Builder = + new org.opendaylight.yang.gen.v1.http + .org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.Interface1Builder(); + + otsiInterfaceBldr.addAugmentation(otsiIf1Builder.setOtsi(otsiBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, otsiInterfaceBldr); + + // Post the equipment-state change on the device circuit-pack if xpdr node + if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { + this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true); + } + + return otsiInterfaceBldr.getName(); + } + + // This is a transponder use-case where the supporting port is just one, but YANG model + // requires supporting port to be list + public String createOpenRoadmOtsiGroupInterface(String nodeId, String logicalConnPoint, + String supportingOtsiInterface) + throws OpenRoadmInterfaceException { + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, + nodeId, logicalConnPoint)); + } + // Create an OTSI group object + OtsiGroupBuilder otsiGroupBuilder = new OtsiGroupBuilder() + .setGroupId(Uint32.valueOf(1)) + .setGroupRate(R400GOtsi.class); + + // Create generic interface + InterfaceBuilder otsiGroupInterfaceBldr = createGenericInterfaceBuilder(portMap, OtsiGroup.class, + logicalConnPoint + "-OTSI-GROUP"); + + // Create a list + List listSupportingOtsiInterface = new ArrayList<>(); + listSupportingOtsiInterface.add(supportingOtsiInterface); + otsiGroupInterfaceBldr.setSupportingInterfaceList(listSupportingOtsiInterface); + + org.opendaylight.yang.gen.v1.http.org.openroadm.otsi.group.interfaces.rev200529.Interface1Builder + otsiGroupIf1Builder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otsi.group.interfaces.rev200529.Interface1Builder(); + otsiGroupInterfaceBldr.addAugmentation(otsiGroupIf1Builder.setOtsiGroup(otsiGroupBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, otsiGroupInterfaceBldr); + + // Post the equipment-state change on the device circuit-pack if xpdr node + if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { + this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true); + } + + return otsiGroupInterfaceBldr.getName(); + } + + public String createOpenRoadmOtucnInterface(String nodeId, String logicalConnPoint, + String supportingOtsiGroupInterface) + throws OpenRoadmInterfaceException { + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, + nodeId, logicalConnPoint)); + } + // Create an OTUCn object + MaintLoopbackBuilder maintLoopbackBuilder = new MaintLoopbackBuilder(); + maintLoopbackBuilder.setEnabled(false); + OtuBuilder otuBuilder = new OtuBuilder() + .setRate(OTUCn.class) + .setOtucnNRate(Uint16.valueOf(4)) + .setTimActEnabled(false) + .setTimDetectMode(TimDetectMode.Disabled) + .setDegmIntervals(Uint8.valueOf(2)) + .setDegthrPercentage(Uint16.valueOf(100)) + .setMaintLoopback(maintLoopbackBuilder.build()); + + InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOtu.class, + logicalConnPoint + "-OTUC4"); + + // Create a list + List listSupportingOtsiGroupInterface = new ArrayList<>(); + listSupportingOtsiGroupInterface.add(supportingOtsiGroupInterface); + + otuInterfaceBuilder.setSupportingInterfaceList(listSupportingOtsiGroupInterface); + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder otuIf1Builder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder(); + + otuInterfaceBuilder.addAugmentation(otuIf1Builder.setOtu(otuBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, otuInterfaceBuilder); + + // Post the equipment-state change on the device circuit-pack if xpdr node + if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { + this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true); + } + + return otuInterfaceBuilder.getName(); + + } + + // Adding method to have SAPI/DAPI information for the OTUCn + public String createOpenRoadmOtucnInterface(String anodeId, String alogicalConnPoint, + String supportingOtsiGroupInterface, String znodeId, String zlogicalConnPoint) + throws OpenRoadmInterfaceException { + Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint); + Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint); + if (portMapA == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, + anodeId, alogicalConnPoint)); + } + // On the Zside + if (portMapZ == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, + znodeId, zlogicalConnPoint)); + + } + // Create an OTUCn object + MaintLoopbackBuilder maintLoopbackBuilder = new MaintLoopbackBuilder(); + maintLoopbackBuilder.setEnabled(false); + OtuBuilder otuBuilder = new OtuBuilder() + .setRate(OTUCn.class) + .setOtucnNRate(Uint16.valueOf(4)) + .setTimActEnabled(false) + .setTimDetectMode(TimDetectMode.Disabled) + .setDegmIntervals(Uint8.valueOf(2)) + .setDegthrPercentage(Uint16.valueOf(100)) + .setMaintLoopback(maintLoopbackBuilder.build()) + .setTxSapi(portMapA.getLcpHashVal()) + .setTxDapi(portMapZ.getLcpHashVal()) + // setting expected SAPI and DAPI values + .setExpectedDapi(portMapA.getLcpHashVal()) + .setExpectedSapi(portMapZ.getLcpHashVal()); + + InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOtu.class, + alogicalConnPoint + "-OTUC4"); + + // Create a list + List listSupportingOtsiGroupInterface = new ArrayList<>(); + listSupportingOtsiGroupInterface.add(supportingOtsiGroupInterface); + + otuInterfaceBuilder.setSupportingInterfaceList(listSupportingOtsiGroupInterface); + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder otuIf1Builder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder(); + + otuInterfaceBuilder.addAugmentation(otuIf1Builder.setOtu(otuBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(anodeId, otuInterfaceBuilder); + + // Post the equipment-state change on the device circuit-pack if xpdr node + if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { + this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true); + } + + return otuInterfaceBuilder.getName(); + + } + + public String createOpenRoadmOducnInterface(String nodeId, String logicalConnPoint, + String supportingOtucn) + throws OpenRoadmInterfaceException { + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, + nodeId, logicalConnPoint)); + } + // Create ODUcn object + // Start with OPU object + // OPU payload + OpuBuilder opuBuilder = new OpuBuilder() + .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22")) + .setPayloadType(PayloadTypeDef.getDefaultInstance("22")); + // Maint test signal + MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() + .setEnabled(false); + + // Create an ODUC4 object + OduBuilder oduBuilder = new OduBuilder() + .setRate(ODUCn.class) + .setOducnNRate(Uint16.valueOf(4)) + .setOduFunction(ODUTTP.class) + .setMonitoringMode(MonitoringMode.Terminated) + .setTimActEnabled(false) + .setTimDetectMode(TimDetectMode.Disabled) + .setDegmIntervals(Uint8.valueOf(2)) + .setDegthrPercentage(Uint16.valueOf(100)) + .setOpu(opuBuilder.build()) + .setMaintTestsignal(maintTestsignal.build()); + + InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class, + logicalConnPoint + "-ODUC4"); + + // Create a list + List listSupportingOtucnInterface = new ArrayList<>(); + listSupportingOtucnInterface.add(supportingOtucn); + + oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface); + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder(); + + oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, oduInterfaceBuilder); + + // Post the equipment-state change on the device circuit-pack if xpdr node + if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { + this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true); + } + + return oduInterfaceBuilder.getName(); + } + + // With SAPI and DAPI information + public String createOpenRoadmOducnInterface(String anodeId, String alogicalConnPoint, + String supportingOtucn, String znodeId, String zlogicalConnPoint) + throws OpenRoadmInterfaceException { + Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint); + Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint); + if (portMapA == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, + anodeId, alogicalConnPoint)); + } + // On the Zside + if (portMapZ == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, + znodeId, zlogicalConnPoint)); + + } + // Create ODUcn object + // Start with OPU object + // OPU payload + OpuBuilder opuBuilder = new OpuBuilder() + .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22")) + .setPayloadType(PayloadTypeDef.getDefaultInstance("22")); + // Maint test signal + MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() + .setEnabled(false); + + // Create an ODUC4 object + OduBuilder oduBuilder = new OduBuilder() + .setRate(ODUCn.class) + .setOducnNRate(Uint16.valueOf(4)) + .setOduFunction(ODUTTP.class) + .setMonitoringMode(MonitoringMode.Terminated) + .setTimActEnabled(false) + .setTimDetectMode(TimDetectMode.Disabled) + .setDegmIntervals(Uint8.valueOf(2)) + .setDegthrPercentage(Uint16.valueOf(100)) + .setOpu(opuBuilder.build()) + .setTxSapi(portMapA.getLcpHashVal()) + .setTxDapi(portMapZ.getLcpHashVal()) + .setExpectedSapi(portMapZ.getLcpHashVal()) + .setExpectedDapi(portMapZ.getLcpHashVal()) + .setMaintTestsignal(maintTestsignal.build()); + + InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class, + alogicalConnPoint + "-ODUC4"); + + // Create a list + List listSupportingOtucnInterface = new ArrayList<>(); + listSupportingOtucnInterface.add(supportingOtucn); + + oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface); + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder(); + + oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(anodeId, oduInterfaceBuilder); + + // Post the equipment-state change on the device circuit-pack if xpdr node + if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { + this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true); + } + + return oduInterfaceBuilder.getName(); + } + + // This is only for transponder + public String createOpenRoadmOduflexInterface(String nodeId, String logicalConnPoint, + String supportingOducn) + throws OpenRoadmInterfaceException { + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, + nodeId, logicalConnPoint)); + } + // OPU payload + OpuBuilder opuBuilder = new OpuBuilder() + .setExpPayloadType(PayloadTypeDef.getDefaultInstance("32")) + .setPayloadType(PayloadTypeDef.getDefaultInstance("32")); + + // Maint test signal + MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() + .setEnabled(false); + + // Parent Odu-allocation + // Set the trib-slot array + List tribslots = new ArrayList<>(); + IntStream.range(1, 5).forEach(a -> IntStream.range(1, 21).forEach(b -> tribslots.add( + OpucnTribSlotDef.getDefaultInstance(a + "." + b)))); + + ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder() + .setTribPortNumber(Uint16.valueOf(1)) + .setTribSlotsChoice(new OpucnBuilder().setOpucnTribSlots(tribslots).build()); + + // Create an ODUFlex object + OduBuilder oduBuilder = new OduBuilder() + .setRate(ODUflexCbr.class) + .setOduflexCbrService(ODUflexCbr400G.class) + .setOduFunction(ODUTTPCTP.class) + .setMonitoringMode(MonitoringMode.Terminated) + .setTimActEnabled(false) + .setTimDetectMode(TimDetectMode.Disabled) + .setDegmIntervals(Uint8.valueOf(2)) + .setDegthrPercentage(Uint16.valueOf(100)) + .setOpu(opuBuilder.build()) + .setMaintTestsignal(maintTestsignal.build()) + .setParentOduAllocation(parentOduAllocationBuilder.build()); + + InterfaceBuilder oduflexInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class, + logicalConnPoint + "-ODUFLEX"); + + List listSupportingOtucnInterface = new ArrayList<>(); + listSupportingOtucnInterface.add(supportingOducn); + + oduflexInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface); + + + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder + oduflexIf1Builder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder(); + + oduflexInterfaceBuilder.addAugmentation(oduflexIf1Builder.setOdu(oduBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, oduflexInterfaceBuilder); + + // Post the equipment-state change on the device circuit-pack if xpdr node + if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { + this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true); + } + + return oduflexInterfaceBuilder.getName(); + } + + // This is only for transponder; with SAPI/DAPI information + public String createOpenRoadmOduflexInterface(String anodeId, String alogicalConnPoint, + String supportingOducn, String znodeId, String zlogicalConnPoint) + throws OpenRoadmInterfaceException { + Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint); + Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint); + if (portMapA == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, + anodeId, alogicalConnPoint)); + } + // On the Zside + if (portMapZ == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, + znodeId, zlogicalConnPoint)); + + } + // OPU payload + OpuBuilder opuBuilder = new OpuBuilder() + .setExpPayloadType(PayloadTypeDef.getDefaultInstance("32")) + .setPayloadType(PayloadTypeDef.getDefaultInstance("32")); + + // Maint test signal + MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() + .setEnabled(false); + + // Parent Odu-allocation + // Set the trib-slot array + List tribslots = new ArrayList<>(); + IntStream.range(1, 5).forEach(a -> IntStream.range(1, 21).forEach(b -> tribslots.add( + OpucnTribSlotDef.getDefaultInstance(a + "." + b)))); + + ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder() + .setTribPortNumber(Uint16.valueOf(1)) + .setTribSlotsChoice(new OpucnBuilder().setOpucnTribSlots(tribslots).build()); + + // Create an ODUFlex object + OduBuilder oduBuilder = new OduBuilder() + .setRate(ODUflexCbr.class) + .setOduflexCbrService(ODUflexCbr400G.class) + .setOduFunction(ODUTTPCTP.class) + .setMonitoringMode(MonitoringMode.Terminated) + .setTimActEnabled(false) + .setTimDetectMode(TimDetectMode.Disabled) + .setDegmIntervals(Uint8.valueOf(2)) + .setDegthrPercentage(Uint16.valueOf(100)) + .setTxSapi(portMapA.getLcpHashVal()) + .setTxDapi(portMapZ.getLcpHashVal()) + .setExpectedSapi(portMapZ.getLcpHashVal()) + .setExpectedDapi(portMapA.getLcpHashVal()) + .setOpu(opuBuilder.build()) + .setMaintTestsignal(maintTestsignal.build()) + .setParentOduAllocation(parentOduAllocationBuilder.build()); + + InterfaceBuilder oduflexInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class, + alogicalConnPoint + "-ODUFLEX"); + + List listSupportingOtucnInterface = new ArrayList<>(); + listSupportingOtucnInterface.add(supportingOducn); + + oduflexInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface); + + + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder + oduflexIf1Builder = + new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder(); + + oduflexInterfaceBuilder.addAugmentation(oduflexIf1Builder.setOdu(oduBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(anodeId, oduflexInterfaceBuilder); + + // Post the equipment-state change on the device circuit-pack if xpdr node + if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { + this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true); + } + + return oduflexInterfaceBuilder.getName(); + } + + // This creates the name of the interface with slot numbers at the end + public String createOpenRoadmOtsiInterfaceName(String logicalConnectionPoint, String spectralSlotName) { + return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotName); + } + + private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class type, + String key) { + return new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder() + .setDescription(" TBD ") + .setCircuitId(" TBD ") + .setSupportingCircuitPackName(portMap.getSupportingCircuitPackName()) + .setSupportingPort(portMap.getSupportingPort()) + .setAdministrativeState(AdminStates.InService) + .setType(type) + .setName(key) + .withKey(new InterfaceKey(key)); + } + +} diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterfaceFactory.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterfaceFactory.java index 6e6dab62b..e170fca76 100644 --- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterfaceFactory.java +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterfaceFactory.java @@ -27,13 +27,16 @@ public class OpenRoadmInterfaceFactory { private final MappingUtils mappingUtils; private final OpenRoadmInterface121 openRoadmInterface121; private final OpenRoadmInterface221 openRoadmInterface221; + private final OpenRoadmInterface710 openRoadmInterface710; private final OpenRoadmOtnInterface221 openRoadmOtnInterface; public OpenRoadmInterfaceFactory(MappingUtils mappingUtils, OpenRoadmInterface121 openRoadmInterface121, - OpenRoadmInterface221 openRoadmInterface221, OpenRoadmOtnInterface221 openRoadmOTNInterface) { + OpenRoadmInterface221 openRoadmInterface221, OpenRoadmInterface710 openRoadmInterface710, + OpenRoadmOtnInterface221 openRoadmOTNInterface) { this.mappingUtils = mappingUtils; this.openRoadmInterface121 = openRoadmInterface121; this.openRoadmInterface221 = openRoadmInterface221; + this.openRoadmInterface710 = openRoadmInterface710; this.openRoadmOtnInterface = openRoadmOTNInterface; } @@ -45,6 +48,8 @@ public class OpenRoadmInterfaceFactory { return openRoadmInterface121.createOpenRoadmEthInterface(nodeId, logicalConnPoint); case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1: return openRoadmInterface221.createOpenRoadmEthInterface(nodeId, logicalConnPoint); + case StringConstants.OPENROADM_DEVICE_VERSION_7_1_0: + return openRoadmInterface710.createOpenRoadmEthInterface(nodeId, logicalConnPoint); default: return null; } @@ -83,7 +88,13 @@ public class OpenRoadmInterfaceFactory { case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1: return openRoadmInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, spectrumInformation); - + case StringConstants.OPENROADM_DEVICE_VERSION_7_1_0: + // In the case of 710 device, we logically combine the OTSi and OTSiGroup interface and represent + // as OCh + String interfaceOtsiName = openRoadmInterface710.createOpenRoadmOtsiInterface(nodeId, logicalConnPoint, + spectrumInformation); + return openRoadmInterface710.createOpenRoadmOtsiGroupInterface(nodeId, logicalConnPoint, + interfaceOtsiName); default: return null; } @@ -108,6 +119,12 @@ public class OpenRoadmInterfaceFactory { case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1: return openRoadmInterface221.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint, supportingOtuInterface); + case StringConstants.OPENROADM_DEVICE_VERSION_7_1_0: + // Here ODUCn and ODUflex are combined + String interfaceNameOduc4 = openRoadmInterface710.createOpenRoadmOducnInterface(nodeId, + logicalConnPoint, supportingOtuInterface); + return openRoadmInterface710.createOpenRoadmOduflexInterface(nodeId, logicalConnPoint, + interfaceNameOduc4); default: return null; } @@ -135,6 +152,12 @@ public class OpenRoadmInterfaceFactory { case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1: return openRoadmInterface221.createOpenRoadmOdu4Interface(anodeId, alogicalConnPoint, asupportingOtuInterface, znodeId, zlogicalConnPoint); + case StringConstants.OPENROADM_DEVICE_VERSION_7_1_0: + // Here ODUCn and ODUflex are combined + String interfaceNameOduc4 = openRoadmInterface710.createOpenRoadmOducnInterface(anodeId, + alogicalConnPoint, asupportingOtuInterface, znodeId, zlogicalConnPoint); + return openRoadmInterface710.createOpenRoadmOduflexInterface(anodeId, alogicalConnPoint, + interfaceNameOduc4, znodeId, zlogicalConnPoint); default: return null; } @@ -159,6 +182,9 @@ public class OpenRoadmInterfaceFactory { case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1: return openRoadmInterface221 .createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface); + case StringConstants.OPENROADM_DEVICE_VERSION_7_1_0: + return openRoadmInterface710.createOpenRoadmOtucnInterface(nodeId, logicalConnPoint, + supportOchInterface); default: return null; } @@ -187,6 +213,9 @@ public class OpenRoadmInterfaceFactory { case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1: return openRoadmInterface221.createOpenRoadmOtu4Interface(anodeId, alogicalConnPoint, asupportOchInterface, znodeId, zlogicalConnPoint); + case StringConstants.OPENROADM_DEVICE_VERSION_7_1_0: + return openRoadmInterface710.createOpenRoadmOtucnInterface(anodeId, alogicalConnPoint, + asupportOchInterface, znodeId, zlogicalConnPoint); default: return null; } diff --git a/renderer/src/main/resources/OSGI-INF/blueprint/renderer-blueprint.xml b/renderer/src/main/resources/OSGI-INF/blueprint/renderer-blueprint.xml index 58088f3e7..2bae23d83 100644 --- a/renderer/src/main/resources/OSGI-INF/blueprint/renderer-blueprint.xml +++ b/renderer/src/main/resources/OSGI-INF/blueprint/renderer-blueprint.xml @@ -37,6 +37,12 @@ and is available at http://www.eclipse.org/legal/epl-v10.html + + + + + @@ -48,6 +54,7 @@ and is available at http://www.eclipse.org/legal/epl-v10.html + 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 21252fe39..a58b2919f 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 @@ -40,6 +40,7 @@ import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfa 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.OpenRoadmInterface710; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221; import org.opendaylight.transportpce.renderer.utils.CreateOtsOmsDataUtils; @@ -99,9 +100,10 @@ public class DeviceRendererServiceImplCreateOtsOmsTest extends AbstractTest { this.portMappingVersion121); OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces); OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces); + OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping, openRoadmInterfaces); OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces); this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121, - openRoadmInterface221, openRoadmOTNInterface); + openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface); this.crossConnectImpl121 = new CrossConnectImpl121(this.deviceTransactionManager); this.crossConnectImpl221 = new CrossConnectImpl221(this.deviceTransactionManager); 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 45ebb1d82..8517c7981 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 @@ -45,6 +45,7 @@ import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfa 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.OpenRoadmInterface710; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221; import org.opendaylight.transportpce.renderer.stub.OlmServiceStub; @@ -120,9 +121,10 @@ public class RendererServiceOperationsImplDeleteTest extends AbstractTest { this.crossConnect = Mockito.spy(crossConnect); OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces); OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces); + OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping,openRoadmInterfaces); OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces); OpenRoadmInterfaceFactory openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils, - openRoadmInterface121, openRoadmInterface221, openRoadmOTNInterface); + openRoadmInterface121, openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface); this.deviceRenderer = new DeviceRendererServiceImpl(getDataBroker(), this.deviceTransactionManager, openRoadmInterfaceFactory, openRoadmInterfaces, crossConnect, 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 cf8dfe2f0..25b112ccf 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 @@ -41,6 +41,7 @@ import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfa 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.OpenRoadmInterface710; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221; import org.opendaylight.transportpce.renderer.stub.OlmServiceStub; @@ -108,9 +109,10 @@ public class RendererServiceOperationsImplTest extends AbstractTest { this.portMappingVersion121); OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces); OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces); + OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping,openRoadmInterfaces); OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces); this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121, - openRoadmInterface221, openRoadmOTNInterface); + openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface); this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager); this.crossConnectImpl221 = new CrossConnectImpl221(deviceTransactionManager); this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121, -- 2.36.6