X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=renderer%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Ftransportpce%2Frenderer%2Fopenroadminterface%2FOpenRoadmInterface710.java;h=7fa28d5f540f2b0af70899e21b9943051c473005;hb=6f2ada72bbf4febe8e176ec2537dfc7e6e561a52;hp=51bb5aedac965a292e61bf8999fa8435b3a1c61e;hpb=e8b516c52451ad5055529b3e11065546a58394b3;p=transportpce.git 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 index 51bb5aeda..7fa28d5f5 100644 --- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java @@ -20,18 +20,27 @@ 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.rev210426.mapping.Mapping; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.az.api.info.AEndApiInfo; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.az.api.info.ZEndApiInfo; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.mapping.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.Foic24; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.Foic28; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.Foic36; 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.R100G; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.R200GOtsi; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.R300GOtsi; 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.common.types.rev200529.Scfec; 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; @@ -39,20 +48,21 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev20 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.OpticalChannel; 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.MaintTestsignal.TestPattern; -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.interfaces.rev200529.och.container.OchBuilder; 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.ODU4; 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.OTU4; 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; @@ -61,17 +71,33 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200 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.yang.gen.v1.http.org.openroadm.port.types.rev201211.If100GE; +import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.IfOCHOTU4ODU4; +import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev201211.IfOtsiOtsigroup; import org.opendaylight.yangtools.yang.common.Uint16; import org.opendaylight.yangtools.yang.common.Uint32; import org.opendaylight.yangtools.yang.common.Uint8; - +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; 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 static final String MODULATION_FMT_EXCEPTION_MESSAGE = + "Unable to get the modulation format"; + private static final String RATE_EXCEPTION_MESSAGE = + "Unable to get the rate"; + private static final String ODUC = "-ODUC"; + private static final List SUPPORTED_ODUCN_RATES = new ArrayList<>() { + { + add("2"); + add("3"); + add("4"); + } + }; private final PortMapping portMapping; private final OpenRoadmInterfaces openRoadmInterfaces; - + private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterface710.class); public OpenRoadmInterface710(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) { this.portMapping = portMapping; @@ -85,14 +111,19 @@ public class OpenRoadmInterface710 { throw new OpenRoadmInterfaceException( String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint)); } - // Ethernet interface specific data EthernetBuilder ethIfBuilder = new EthernetBuilder() .setFec(Rsfec.class) + // Default set to 400G .setSpeed(Uint32.valueOf(400000)); + // We have to differentiate if-100GE vs if-400GE + if (portMap.getSupportedInterfaceCapability().contains(If100GE.class)) { + ethIfBuilder.setSpeed(Uint32.valueOf(100000)); + } 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()); @@ -106,32 +137,123 @@ public class OpenRoadmInterface710 { return ethInterfaceBldr.getName(); } + public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, + SpectrumInformation spectrumInformation) + throws OpenRoadmInterfaceException { + + ModulationFormat modulationFormat = ModulationFormat.DpQpsk; + Optional optionalModulationFormat = ModulationFormat + .forName(spectrumInformation.getModulationFormat()); + if (optionalModulationFormat.isPresent()) { + modulationFormat = optionalModulationFormat.get(); + } + // OCH interface specific data + OchBuilder ocIfBuilder = new OchBuilder() + .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency())) + .setRate(R100G.class) + .setTransmitPower(new PowerDBm(new BigDecimal("-5"))) + .setModulationFormat(modulationFormat); + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException( + String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s", + nodeId, logicalConnPoint)); + } + // Create generic interface + InterfaceBuilder + ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class, + spectrumInformation.getIdentifierFromParams(logicalConnPoint)); + // Create Interface1 type object required for adding as augmentation + // TODO look at imports of different versions of class + org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev200529.Interface1Builder + ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev200529 + .Interface1Builder(); + ochInterfaceBldr.addAugmentation(ochIf1Builder.setOch(ocIfBuilder.build()).build()); + + // Post interface on the device + openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr); + + // 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 ochInterfaceBldr.getName(); + } public String createOpenRoadmOtsiInterface(String nodeId, String logicalConnPoint, SpectrumInformation spectrumInformation) throws OpenRoadmInterfaceException { - // TODO : Check this method - ModulationFormat modulationFormat = ModulationFormat.DpQam16; + + ModulationFormat modulationFormat; Optional optionalModulationFormat = ModulationFormat .forName(spectrumInformation.getModulationFormat()); if (optionalModulationFormat.isPresent()) { modulationFormat = optionalModulationFormat.get(); + } else { + throw new OpenRoadmInterfaceException( + String.format(MODULATION_FMT_EXCEPTION_MESSAGE)); } - // 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()); + .setModulationFormat(modulationFormat); + + // Set the Flexo values + FlexoBuilder flexoBuilder = new FlexoBuilder(); + boolean rateNotFound = false; + // Use the rate to switch rather than modulation format + int serviceRate = getServiceRate(modulationFormat, spectrumInformation); + switch (serviceRate) { + case 200: + LOG.info("Given modulation format is {} and thus rate is 200G", modulationFormat); + if (modulationFormat == ModulationFormat.DpQam16) { + LOG.info("FOIC is 2.8 for 31.6 Gbaud and rate is 200"); + // FOIC rate is different + flexoBuilder.setFoicType(Foic28.class) + .setIid(new ArrayList<>(Arrays.asList(Uint8.valueOf(1), Uint8.valueOf(2), + Uint8.valueOf(3), Uint8.valueOf(4)))); + } else { + // default is dp-qpsk for 200G under 63.1 GBaud + flexoBuilder.setFoicType(Foic24.class) + .setIid(new ArrayList<>(Arrays.asList(Uint8.valueOf(1), Uint8.valueOf(2)))); + } + otsiBuilder.setOtsiRate(R200GOtsi.class) + .setFlexo(flexoBuilder.build()); + break; + case 300: + LOG.info("Given modulation format is {} and thus rate is 300G", modulationFormat); + flexoBuilder.setFoicType(Foic36.class) + .setIid(new ArrayList<>(Arrays.asList(Uint8.valueOf(1), Uint8.valueOf(2), + Uint8.valueOf(3)))); + otsiBuilder.setOtsiRate(R300GOtsi.class) + .setFlexo(flexoBuilder.build()); + break; + case 400: + // Default baud-rate is 63.1 Gbaud + LOG.info("Given modulation format is {} and thus rate is 400G", modulationFormat); + flexoBuilder.setFoicType(Foic48.class) + .setIid(new ArrayList<>(Arrays.asList(Uint8.valueOf(1), Uint8.valueOf(2), + Uint8.valueOf(3), Uint8.valueOf(4)))); + otsiBuilder.setModulationFormat(modulationFormat) + .setOtsiRate(R400GOtsi.class) + .setFlexo(flexoBuilder.build()); + break; + default: + LOG.error("Rate {} is unsupported", serviceRate); + rateNotFound = true; + break; + } + + if (rateNotFound) { + throw new OpenRoadmInterfaceException( + String.format(RATE_EXCEPTION_MESSAGE)); + } + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); if (portMap == null) { throw new OpenRoadmInterfaceException( @@ -140,10 +262,9 @@ public class OpenRoadmInterface710 { // 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 = + .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(); @@ -163,7 +284,7 @@ public class OpenRoadmInterface710 { // 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) + String supportingOtsiInterface, SpectrumInformation spectrumInformation) throws OpenRoadmInterfaceException { Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); if (portMap == null) { @@ -171,14 +292,44 @@ public class OpenRoadmInterface710 { String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint)); } + // Check the modulation format + ModulationFormat modulationFormat; + Optional optionalModulationFormat = ModulationFormat + .forName(spectrumInformation.getModulationFormat()); + if (optionalModulationFormat.isPresent()) { + modulationFormat = optionalModulationFormat.get(); + } else { + throw new OpenRoadmInterfaceException( + String.format(MODULATION_FMT_EXCEPTION_MESSAGE)); + } + int serviceRate = getServiceRate(modulationFormat, spectrumInformation); // Create an OTSI group object OtsiGroupBuilder otsiGroupBuilder = new OtsiGroupBuilder() - .setGroupId(Uint32.valueOf(1)) - .setGroupRate(R400GOtsi.class); + .setGroupId(Uint32.valueOf(1)); + boolean rateNotFound = false; + switch (serviceRate) { + case 200: + otsiGroupBuilder.setGroupRate(R200GOtsi.class); + break; + case 300: + otsiGroupBuilder.setGroupRate(R300GOtsi.class); + break; + case 400: + otsiGroupBuilder.setGroupRate(R400GOtsi.class); + break; + default: + LOG.error("Rate {} is not supported", serviceRate); + rateNotFound = true; + break; + } + if (rateNotFound) { + throw new OpenRoadmInterfaceException( + String.format(RATE_EXCEPTION_MESSAGE)); + } // Create generic interface InterfaceBuilder otsiGroupInterfaceBldr = createGenericInterfaceBuilder(portMap, OtsiGroup.class, - logicalConnPoint + "-OTSI-GROUP"); + logicalConnPoint + String.join("-", "", "OTSIGROUP", serviceRate + "G")); // Create a list List listSupportingOtsiInterface = new ArrayList<>(); @@ -186,7 +337,7 @@ public class OpenRoadmInterface710 { otsiGroupInterfaceBldr.setSupportingInterfaceList(listSupportingOtsiInterface); org.opendaylight.yang.gen.v1.http.org.openroadm.otsi.group.interfaces.rev200529.Interface1Builder - otsiGroupIf1Builder = + otsiGroupIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.otsi.group.interfaces.rev200529.Interface1Builder(); otsiGroupInterfaceBldr.addAugmentation(otsiGroupIf1Builder.setOtsiGroup(otsiGroupBuilder.build()).build()); @@ -201,89 +352,137 @@ public class OpenRoadmInterface710 { return otsiGroupInterfaceBldr.getName(); } - public String createOpenRoadmOtucnInterface(String nodeId, String logicalConnPoint, - String supportingOtsiGroupInterface) - throws OpenRoadmInterfaceException { + public String createOpenRoadmOchOtsiOtsigroupInterface(String nodeId, String logicalConnPoint, + SpectrumInformation spectrumInformation) + throws OpenRoadmInterfaceException { Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); if (portMap == null) { throw new OpenRoadmInterfaceException( - String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, - nodeId, logicalConnPoint)); + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint)); + } + String interfaceOchOtsiOtsigroup = null; + if (portMap.getSupportedInterfaceCapability().contains(IfOCHOTU4ODU4.class)) { + // create OCH interface + interfaceOchOtsiOtsigroup = createOpenRoadmOchInterface(nodeId, logicalConnPoint, spectrumInformation); + } else if (portMap.getSupportedInterfaceCapability().contains(IfOtsiOtsigroup.class)) { + // Create OTSi and OTSi-group and concat the names of the interface + String interfaceOtsiName = createOpenRoadmOtsiInterface(nodeId, logicalConnPoint, spectrumInformation); + // Concat the two names for this interface + interfaceOchOtsiOtsigroup = interfaceOtsiName + + "#" + createOpenRoadmOtsiGroupInterface(nodeId, logicalConnPoint, interfaceOtsiName, + spectrumInformation); } - // 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"); + return interfaceOchOtsiOtsigroup; + } - // Create a list - List listSupportingOtsiGroupInterface = new ArrayList<>(); - listSupportingOtsiGroupInterface.add(supportingOtsiGroupInterface); + public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface, + AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ) throws OpenRoadmInterfaceException { - otuInterfaceBuilder.setSupportingInterfaceList(listSupportingOtsiGroupInterface); + Mapping mapping = this.portMapping.getMapping(nodeId, logicalConnPoint); + if (mapping == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint)); + } + InterfaceBuilder + otuInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOtu.class, + logicalConnPoint + "-OTU4"); + // Supporting interface list + List listSupportingOChInterface = new ArrayList<>(); + listSupportingOChInterface.add(supportOchInterface); + otuInterfaceBldr.setSupportingInterfaceList(listSupportingOChInterface); + + // OTU interface specific data + org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.otu.container.OtuBuilder + otuIfBuilder = new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu + .interfaces.rev200529.otu.container.OtuBuilder() + .setFec(Scfec.class) + .setRate(OTU4.class); + if (apiInfoA != null) { + otuIfBuilder.setTxSapi(apiInfoA.getSapi()) + .setTxDapi(apiInfoA.getDapi()) + .setExpectedSapi(apiInfoA.getExpectedSapi()) + .setExpectedDapi(apiInfoA.getExpectedDapi()); + } + if (apiInfoZ != null) { + otuIfBuilder.setTxSapi(apiInfoZ.getSapi()) + .setTxDapi(apiInfoZ.getDapi()) + .setExpectedSapi(apiInfoZ.getExpectedSapi()) + .setExpectedDapi(apiInfoZ.getExpectedDapi()); + } + + // Create Interface1 type object required for adding as augmentation + // TODO look at imports of different versions of class 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()); + otuInterfaceBldr.addAugmentation(otuIf1Builder.setOtu(otuIfBuilder.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(); - + openRoadmInterfaces.postInterface(nodeId, otuInterfaceBldr); + this.portMapping.updateMapping(nodeId, mapping); + return otuInterfaceBldr.getName(); } - // Adding method to have SAPI/DAPI information for the OTUCn - public String createOpenRoadmOtucnInterface(String anodeId, String alogicalConnPoint, - String supportingOtsiGroupInterface, String znodeId, String zlogicalConnPoint) + + public String createOpenRoadmOtucnInterface(String nodeId, String logicalConnPoint, + String supportingOtsiGroupInterface, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ) throws OpenRoadmInterfaceException { - Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint); - Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint); - if (portMapA == null) { + Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint); + if (mapping == 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)); - + 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()) - .setTxSapi(portMapA.getLcpHashVal()) - .setTxDapi(portMapZ.getLcpHashVal()) - // setting expected SAPI and DAPI values - .setExpectedDapi(portMapA.getLcpHashVal()) - .setExpectedSapi(portMapZ.getLcpHashVal()); + .setDegthrPercentage(Uint16.valueOf(100)); - InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOtu.class, - alogicalConnPoint + "-OTUC4"); + if (apiInfoA != null) { + otuBuilder.setTxSapi(apiInfoA.getSapi()) + .setTxDapi(apiInfoA.getDapi()) + .setExpectedSapi(apiInfoA.getExpectedSapi()) + .setExpectedDapi(apiInfoA.getExpectedDapi()); + } + if (apiInfoZ != null) { + otuBuilder.setTxSapi(apiInfoZ.getSapi()) + .setTxDapi(apiInfoZ.getDapi()) + .setExpectedSapi(apiInfoZ.getExpectedSapi()) + .setExpectedDapi(apiInfoZ.getExpectedDapi()); + } + // Set the OTUCn rate for various rates + String rate = supportingOtsiGroupInterface.substring(supportingOtsiGroupInterface.lastIndexOf('-') + 1); + + String otucnrate = null; + boolean rateNotFound = false; + switch (rate) { + case "200G": + otuBuilder.setOtucnNRate(Uint16.valueOf(2)); + otucnrate = "2"; + break; + case "300G": + otuBuilder.setOtucnNRate(Uint16.valueOf(3)); + otucnrate = "3"; + break; + case "400G": + otuBuilder.setOtucnNRate(Uint16.valueOf(4)); + otucnrate = "4"; + break; + default: + LOG.error("Rate {} is not supported", rate); + rateNotFound = true; + break; + } + if (rateNotFound) { + throw new OpenRoadmInterfaceException( + String.format(RATE_EXCEPTION_MESSAGE)); + } + + InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(mapping, OtnOtu.class, + logicalConnPoint + "-OTUC" + otucnrate); // Create a list List listSupportingOtsiGroupInterface = new ArrayList<>(); @@ -296,151 +495,98 @@ public class OpenRoadmInterface710 { otuInterfaceBuilder.addAugmentation(otuIf1Builder.setOtu(otuBuilder.build()).build()); // Post interface on the device - openRoadmInterfaces.postInterface(anodeId, otuInterfaceBuilder); - + openRoadmInterfaces.postInterface(nodeId, 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); + if (mapping.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { + this.openRoadmInterfaces.postEquipmentState(nodeId, mapping.getSupportingCircuitPackName(), true); } - + this.portMapping.updateMapping(nodeId, mapping); return otuInterfaceBuilder.getName(); - } - public String createOpenRoadmOducnInterface(String nodeId, String logicalConnPoint, - String supportingOtucn) - throws OpenRoadmInterfaceException { + public String createOpenRoadmOtu4OtucnInterface(String nodeId, String logicalConnPoint, + String supportingInterface, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ) + throws OpenRoadmInterfaceException { Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); if (portMap == null) { throw new OpenRoadmInterfaceException( - String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, - nodeId, logicalConnPoint)); + 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() - // PRBS value should be PRBS31 if enabled is true - .setTestPattern(TestPattern.PRBS31) - .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); + // Depending on OCH-OTU4-ODU4 interface or OTSi-OTSi-group, supporting interface should + // reflect that + String interfaceOtu4Otucn = null; + if (portMap.getSupportedInterfaceCapability().contains(IfOCHOTU4ODU4.class)) { + // create OTU4 interface + interfaceOtu4Otucn = createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportingInterface, + apiInfoA, apiInfoZ); + } else if (portMap.getSupportedInterfaceCapability().contains(IfOtsiOtsigroup.class)) { + // Create OTUCn + interfaceOtu4Otucn = createOpenRoadmOtucnInterface(nodeId, logicalConnPoint, supportingInterface, + apiInfoA, apiInfoZ); } - return oduInterfaceBuilder.getName(); + return interfaceOtu4Otucn; } - // 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) { + public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, + AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ) throws OpenRoadmInterfaceException { + + Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint); + if (mapping == null) { throw new OpenRoadmInterfaceException( - String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, - anodeId, alogicalConnPoint)); + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint)); } - // On the Zside - if (portMapZ == null) { - throw new OpenRoadmInterfaceException( - String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, - znodeId, zlogicalConnPoint)); - + InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOdu.class, + logicalConnPoint + "-ODU4"); + List listSupportingOtu4Interface = new ArrayList<>(); + if (mapping.getSupportingOtu4() != null) { + listSupportingOtu4Interface.add(mapping.getSupportingOtu4()); + oduInterfaceBldr.setSupportingInterfaceList(listSupportingOtu4Interface); } - // 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() - // PRBS value should be PRBS31 if enabled is true - .setTestPattern(TestPattern.PRBS31) - .setEnabled(false); + .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07")) + .setPayloadType(PayloadTypeDef.getDefaultInstance("07")); - // Create an ODUC4 object + // Create an ODU4 object OduBuilder oduBuilder = new OduBuilder() - .setRate(ODUCn.class) - .setOducnNRate(Uint16.valueOf(4)) + .setRate(ODU4.class) .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"); + .setOpu(opuBuilder.build()); - // Create a list - List listSupportingOtucnInterface = new ArrayList<>(); - listSupportingOtucnInterface.add(supportingOtucn); - - oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface); + if (apiInfoA != null) { + oduBuilder.setTxSapi(apiInfoA.getSapi()) + .setTxDapi(apiInfoA.getDapi()) + .setExpectedSapi(apiInfoA.getExpectedSapi()) + .setExpectedDapi(apiInfoA.getExpectedDapi()); + } + if (apiInfoZ != null) { + oduBuilder.setTxSapi(apiInfoZ.getSapi()) + .setTxDapi(apiInfoZ.getDapi()) + .setExpectedSapi(apiInfoZ.getExpectedSapi()) + .setExpectedDapi(apiInfoZ.getExpectedDapi()); + } 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()); + oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build()); // Post interface on the device - openRoadmInterfaces.postInterface(anodeId, oduInterfaceBuilder); + openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr); + // Since this is not a CTP, we can update the port-mapping + LOG.info("{}-{} updating mapping with interface {}", nodeId, logicalConnPoint, oduInterfaceBldr.getName()); + this.portMapping.updateMapping(nodeId, mapping); - // 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(); + return oduInterfaceBldr.getName(); } - public String createOpenRoadmOtnOducnInterface(String nodeId, String logicalConnPoint, - String supportingOtucn) - throws OpenRoadmInterfaceException { - Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); - if (portMap == null) { + + public String createOpenRoadmOducnInterface(String nodeId, String logicalConnPoint) + throws OpenRoadmInterfaceException { + Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint); + if (mapping == null) { throw new OpenRoadmInterfaceException( String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint)); @@ -451,31 +597,42 @@ public class OpenRoadmInterface710 { OpuBuilder opuBuilder = new OpuBuilder() .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22")) .setPayloadType(PayloadTypeDef.getDefaultInstance("22")); - // Maint test signal - MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() - // PRBS value should be PRBS31 if enabled is true - .setTestPattern(TestPattern.PRBS31) - .setEnabled(false); - // Create an ODUC4 object + // Create an ODUCn 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"); + .setOducnNRate(Uint16.valueOf(4)) + .setOpu(opuBuilder.build()); // Create a list + String supportingOtucn; List listSupportingOtucnInterface = new ArrayList<>(); - listSupportingOtucnInterface.add(supportingOtucn); + if (mapping.getSupportingOtucn() != null) { + listSupportingOtucnInterface.add(mapping.getSupportingOtucn()); + supportingOtucn = mapping.getSupportingOtucn(); + } else { + throw new OpenRoadmInterfaceException( + String.format("Missing supporting OTUCn interface on port-mapping")); + } + + // Set the ODUCn rate from OTUCn interface naming convention + String oducnrate = supportingOtucn.substring(supportingOtucn.length() - 1); + // check if the oducnrate is a valid value and if it is invalid, then throw error + if (!SUPPORTED_ODUCN_RATES.contains(oducnrate)) { + throw new OpenRoadmInterfaceException( + String.format(RATE_EXCEPTION_MESSAGE)); + } + + oduBuilder.setOducnNRate(Uint16.valueOf(oducnrate)); + + InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(mapping, OtnOdu.class, + logicalConnPoint + "-ODUC" + oducnrate); oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface); org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder = @@ -487,17 +644,16 @@ public class OpenRoadmInterface710 { 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); + if (mapping.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { + this.openRoadmInterfaces.postEquipmentState(nodeId, mapping.getSupportingCircuitPackName(), true); } - // Update the port-mapping with the interface information - this.portMapping.updateMapping(nodeId, portMap); + return oduInterfaceBuilder.getName(); } - + // Overloaded methods should be together // With SAPI and DAPI information - public String createOpenRoadmOtnOducnInterface(String anodeId, String alogicalConnPoint, + public String createOpenRoadmOducnInterface(String anodeId, String alogicalConnPoint, String supportingOtucn, String znodeId, String zlogicalConnPoint) throws OpenRoadmInterfaceException { Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint); @@ -520,16 +676,10 @@ public class OpenRoadmInterface710 { OpuBuilder opuBuilder = new OpuBuilder() .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22")) .setPayloadType(PayloadTypeDef.getDefaultInstance("22")); - // Maint test signal - MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() - // PRBS value should be PRBS31 if enabled is true - .setTestPattern(TestPattern.PRBS31) - .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) @@ -540,11 +690,21 @@ public class OpenRoadmInterface710 { .setTxSapi(portMapA.getLcpHashVal()) .setTxDapi(portMapZ.getLcpHashVal()) .setExpectedSapi(portMapZ.getLcpHashVal()) - .setExpectedDapi(portMapZ.getLcpHashVal()) - .setMaintTestsignal(maintTestsignal.build()); + .setExpectedDapi(portMapZ.getLcpHashVal()); + + // Set the ODUCn rate from OTUCn interface naming convention + String oducnrate = supportingOtucn.substring(supportingOtucn.length() - 1); + + // check if the oducnrate is a valid value and if it is invalid, then throw error + if (!SUPPORTED_ODUCN_RATES.contains(oducnrate)) { + throw new OpenRoadmInterfaceException( + String.format(RATE_EXCEPTION_MESSAGE)); + } + + oduBuilder.setOducnNRate(Uint16.valueOf(oducnrate)); InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class, - alogicalConnPoint + "-ODUC4"); + alogicalConnPoint + ODUC + oducnrate); // Create a list List listSupportingOtucnInterface = new ArrayList<>(); @@ -563,15 +723,15 @@ public class OpenRoadmInterface710 { if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) { this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true); } - // Update the port-mapping with the interface information - this.portMapping.updateMapping(anodeId, portMapA); + return oduInterfaceBuilder.getName(); } + // This is only for transponder public String createOpenRoadmOduflexInterface(String nodeId, String logicalConnPoint, - String supportingOducn) - throws OpenRoadmInterfaceException { + String supportingOducn) + throws OpenRoadmInterfaceException { Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); if (portMap == null) { throw new OpenRoadmInterfaceException( @@ -583,12 +743,6 @@ public class OpenRoadmInterface710 { .setExpPayloadType(PayloadTypeDef.getDefaultInstance("32")) .setPayloadType(PayloadTypeDef.getDefaultInstance("32")); - // Maint test signal - MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() - // PRBS value should be PRBS31 if enabled is true - .setTestPattern(TestPattern.PRBS31) - .setEnabled(false); - // Parent Odu-allocation // Set the trib-slot array List tribslots = new ArrayList<>(); @@ -610,7 +764,6 @@ public class OpenRoadmInterface710 { .setDegmIntervals(Uint8.valueOf(2)) .setDegthrPercentage(Uint16.valueOf(100)) .setOpu(opuBuilder.build()) - .setMaintTestsignal(maintTestsignal.build()) .setParentOduAllocation(parentOduAllocationBuilder.build()); InterfaceBuilder oduflexInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class, @@ -623,7 +776,7 @@ public class OpenRoadmInterface710 { org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder - oduflexIf1Builder = + oduflexIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder(); oduflexInterfaceBuilder.addAugmentation(oduflexIf1Builder.setOdu(oduBuilder.build()).build()); @@ -639,10 +792,11 @@ public class OpenRoadmInterface710 { return oduflexInterfaceBuilder.getName(); } + // Overloaded methods should be together // This is only for transponder; with SAPI/DAPI information public String createOpenRoadmOduflexInterface(String anodeId, String alogicalConnPoint, - String supportingOducn, String znodeId, String zlogicalConnPoint) - throws OpenRoadmInterfaceException { + String supportingOducn, String znodeId, String zlogicalConnPoint) + throws OpenRoadmInterfaceException { Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint); Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint); if (portMapA == null) { @@ -662,12 +816,6 @@ public class OpenRoadmInterface710 { .setExpPayloadType(PayloadTypeDef.getDefaultInstance("32")) .setPayloadType(PayloadTypeDef.getDefaultInstance("32")); - // Maint test signal - MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder() - // PRBS value should be PRBS31 if enabled is true - .setTestPattern(TestPattern.PRBS31) - .setEnabled(false); - // Parent Odu-allocation // Set the trib-slot array List tribslots = new ArrayList<>(); @@ -693,7 +841,6 @@ public class OpenRoadmInterface710 { .setExpectedSapi(portMapZ.getLcpHashVal()) .setExpectedDapi(portMapA.getLcpHashVal()) .setOpu(opuBuilder.build()) - .setMaintTestsignal(maintTestsignal.build()) .setParentOduAllocation(parentOduAllocationBuilder.build()); InterfaceBuilder oduflexInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class, @@ -706,7 +853,7 @@ public class OpenRoadmInterface710 { org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder - oduflexIf1Builder = + oduflexIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder(); oduflexInterfaceBuilder.addAugmentation(oduflexIf1Builder.setOdu(oduBuilder.build()).build()); @@ -722,9 +869,172 @@ public class OpenRoadmInterface710 { return oduflexInterfaceBuilder.getName(); } + public String createOpenRoadmOdu4OducnOduflex(String nodeId, String logicalConnPoint, + AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ) throws OpenRoadmInterfaceException { + + Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint); + if (portMap == null) { + throw new OpenRoadmInterfaceException( + String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint)); + } + // Depending on OTU4 or OTUCn, supporting interface should + // reflect that + String interfaceOdu4OducnOduflex = null; + if (portMap.getSupportedInterfaceCapability().contains(IfOCHOTU4ODU4.class)) { + // create OTU4 interface + interfaceOdu4OducnOduflex = createOpenRoadmOdu4Interface(nodeId, logicalConnPoint, apiInfoA, apiInfoZ); + } else if (portMap.getSupportedInterfaceCapability().contains(IfOtsiOtsigroup.class)) { + // Create ODUCn and ODUFlex interface. + String interfaceOducn = createOpenRoadmOducnInterface(nodeId, logicalConnPoint); + // Here we concat the two interfaces + interfaceOdu4OducnOduflex = interfaceOducn + "#" + + createOpenRoadmOduflexInterface(nodeId, logicalConnPoint, interfaceOducn); + } + + return interfaceOdu4OducnOduflex; + } + + public String createOpenRoadmOtnOducnInterface(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")); + + // Create an ODUC4 object + OduBuilder oduBuilder = new OduBuilder() + .setRate(ODUCn.class) + .setOduFunction(ODUTTP.class) + .setMonitoringMode(MonitoringMode.Terminated) + .setTimActEnabled(false) + .setTimDetectMode(TimDetectMode.Disabled) + .setDegmIntervals(Uint8.valueOf(2)) + .setDegthrPercentage(Uint16.valueOf(100)) + .setOpu(opuBuilder.build()); + + // Set the ODUCn rate from OTUCn interface naming convention + String oducnrate = supportingOtucn.substring(supportingOtucn.length() - 1); + + // check if the oducnrate is a valid value and if it is invalid, then throw error + if (!SUPPORTED_ODUCN_RATES.contains(oducnrate)) { + throw new OpenRoadmInterfaceException( + String.format(RATE_EXCEPTION_MESSAGE)); + } + + oduBuilder.setOducnNRate(Uint16.valueOf(oducnrate)); + + InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class, + logicalConnPoint + ODUC + oducnrate); + + // 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); + } + // Update the port-mapping with the interface information + this.portMapping.updateMapping(nodeId, portMap); + return oduInterfaceBuilder.getName(); + } + + + // With SAPI and DAPI information + public String createOpenRoadmOtnOducnInterface(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")); + + // Create an ODUCn object + OduBuilder oduBuilder = new OduBuilder() + .setRate(ODUCn.class) + .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()); + + // Set the ODUCn rate from OTUCn interface naming convention + String oducnrate = supportingOtucn.substring(supportingOtucn.length() - 1); + + // check if the oducnrate is a valid value and if it is invalid, then throw error + if (!SUPPORTED_ODUCN_RATES.contains(oducnrate)) { + throw new OpenRoadmInterfaceException( + String.format(RATE_EXCEPTION_MESSAGE)); + } + + oduBuilder.setOducnNRate(Uint16.valueOf(oducnrate)); + + InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class, + alogicalConnPoint + ODUC + oducnrate); + + // 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); + } + // Update the port-mapping with the interface information + this.portMapping.updateMapping(anodeId, portMapA); + return oduInterfaceBuilder.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); + return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR, logicalConnectionPoint, spectralSlotName); } private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class type, @@ -740,4 +1050,39 @@ public class OpenRoadmInterface710 { .withKey(new InterfaceKey(key)); } + @edu.umd.cs.findbugs.annotations.SuppressFBWarnings( + value = "UPM_UNCALLED_PRIVATE_METHOD", + justification = "call in call() method") + private int getServiceRate(ModulationFormat modulationFormat, SpectrumInformation spectrumInformation) { + + switch (modulationFormat) { + case DpQpsk: + LOG.info("Given modulation format is {} and thus rate is 200G", modulationFormat); + return 200; + case DpQam8: + LOG.info("Given modulation format is {} and thus rate is 300G", modulationFormat); + return 300; + case DpQam16: + // DpQam16 is possible for both 31.6 or 63.1 GBaud, for which spectral width is different + // Here take the difference of highest and lowest spectral numbers and determine the width + LOG.info("The width with guard band {}", (spectrumInformation.getHigherSpectralSlotNumber() + - spectrumInformation.getLowerSpectralSlotNumber() + 1) * GridConstant.GRANULARITY); + if ((spectrumInformation.getHigherSpectralSlotNumber() + - spectrumInformation.getLowerSpectralSlotNumber() + 1) * GridConstant.GRANULARITY == 50.0) { + // Based on roll-of-factor of 0.5, 50 - 12.5 = 37.5GHz translates to 31.6 GBaud + LOG.info("The baud-rate is 31.6 GBaud"); + LOG.info("Given modulation format {} with 31.6 Gbaud rate is 200G", modulationFormat); + return 200; + } else { + // Based on roll-of-factor of 0.5, 87.5 - 12.5 = 75GHz translates to 63.1 GBaud + LOG.info("The baud-rate is 63.1 GBaud"); + return 400; + } + default: + LOG.error("Modulation format is required to select the rate"); + break; + } + return 0; + } + }