renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java

   1 /*
   2  * Copyright © 2021 AT&T and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.transportpce.renderer.openroadminterface;
  10
  11 import java.math.BigDecimal;
  12 import java.util.ArrayList;
  13 import java.util.Arrays;
  14 import java.util.List;
  15 import java.util.Optional;
  16 import java.util.stream.IntStream;
  17 import org.opendaylight.transportpce.common.StringConstants;
  18 import org.opendaylight.transportpce.common.fixedflex.GridConstant;
  19 import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
  20 import org.opendaylight.transportpce.common.mapping.PortMapping;
  21 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
  22 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
  23 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.mapping.Mapping;
  24 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.TrailTraceOther.TimDetectMode;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.parent.odu.allocation.ParentOduAllocationBuilder;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.parent.odu.allocation.parent.odu.allocation.trib.slots.choice.OpucnBuilder;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.link.types.rev191129.PowerDBm;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.Foic48;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyTHz;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.ModulationFormat;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.ProvisionModeType;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.R400GOtsi;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev200529.Ofec;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev200529.Rsfec;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceKey;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev200529.Interface1Builder;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev200529.ethernet.container.EthernetBuilder;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.EthernetCsmacd;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.InterfaceType;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.OtnOdu;
  43 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.OtnOtu;
  44 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.Otsi;
  45 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.OtsiGroup;
  46 import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.loopback.rev191129.maint.loopback.MaintLoopbackBuilder;
  47 import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.testsignal.rev200529.maint.testsignal.MaintTestsignal.TestPattern;
  48 import org.opendaylight.yang.gen.v1.http.org.openroadm.maintenance.testsignal.rev200529.maint.testsignal.MaintTestsignalBuilder;
  49 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.otsi.attributes.FlexoBuilder;
  50 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.otsi.container.OtsiBuilder;
  51 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUCn;
  52 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUTTP;
  53 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUTTPCTP;
  54 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUflexCbr;
  55 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUflexCbr400G;
  56 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OTUCn;
  57 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef;
  58 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.PayloadTypeDef;
  59 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.OduAttributes.MonitoringMode;
  60 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.odu.container.OduBuilder;
  61 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.opu.OpuBuilder;
  62 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.otu.container.OtuBuilder;
  63 import org.opendaylight.yang.gen.v1.http.org.openroadm.otsi.group.interfaces.rev200529.otsi.group.container.OtsiGroupBuilder;
  64 import org.opendaylight.yangtools.yang.common.Uint16;
  65 import org.opendaylight.yangtools.yang.common.Uint32;
  66 import org.opendaylight.yangtools.yang.common.Uint8;
  67
  68
  69 public class OpenRoadmInterface710 {
  70     private static final String MAPPING_ERROR_EXCEPTION_MESSAGE =
  71         "Unable to get mapping from PortMapping for node % and logical connection port %s";
  72     private final PortMapping portMapping;
  73     private final OpenRoadmInterfaces openRoadmInterfaces;
  74
  75
  76     public OpenRoadmInterface710(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) {
  77         this.portMapping = portMapping;
  78         this.openRoadmInterfaces = openRoadmInterfaces;
  79     }
  80
  81     public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
  82             throws OpenRoadmInterfaceException {
  83         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
  84         if (portMap == null) {
  85             throw new OpenRoadmInterfaceException(
  86                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
  87         }
  88
  89         // Ethernet interface specific data
  90         EthernetBuilder ethIfBuilder = new EthernetBuilder()
  91             .setFec(Rsfec.class)
  92             .setSpeed(Uint32.valueOf(400000));
  93
  94         InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.class,
  95             logicalConnPoint + "-ETHERNET");
  96         // Create Interface1 type object required for adding as augmentation
  97         Interface1Builder ethIf1Builder = new Interface1Builder();
  98         ethInterfaceBldr.addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
  99
 100         // Post interface on the device
 101         openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr);
 102
 103         // Post the equipment-state change on the device circuit-pack
 104         openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 105
 106         return ethInterfaceBldr.getName();
 107     }
 108
 109
 110     public String createOpenRoadmOtsiInterface(String nodeId, String logicalConnPoint,
 111             SpectrumInformation spectrumInformation)
 112             throws OpenRoadmInterfaceException {
 113         // TODO : Check this method
 114         ModulationFormat modulationFormat = ModulationFormat.DpQam16;
 115         Optional<ModulationFormat> optionalModulationFormat = ModulationFormat
 116             .forName(spectrumInformation.getModulationFormat());
 117         if (optionalModulationFormat.isPresent()) {
 118             modulationFormat =  optionalModulationFormat.get();
 119         }
 120         // Set the Flexo values
 121         FlexoBuilder flexoBuilder = new FlexoBuilder()
 122             .setFoicType(Foic48.class)
 123             .setIid(new ArrayList<>(Arrays.asList(Uint8.valueOf(1), Uint8.valueOf(2),
 124                 Uint8.valueOf(3), Uint8.valueOf(4))));
 125
 126         // OTSI interface specific data
 127         OtsiBuilder  otsiBuilder = new OtsiBuilder()
 128             .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency()))
 129             .setTransmitPower(new PowerDBm(new BigDecimal("-5")))
 130             .setModulationFormat(modulationFormat)
 131             .setOtsiRate(R400GOtsi.class)
 132             .setProvisionMode(ProvisionModeType.Explicit)
 133             .setFec(Ofec.class)
 134             .setFlexo(flexoBuilder.build());
 135         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 136         if (portMap == null) {
 137             throw new OpenRoadmInterfaceException(
 138                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
 139         }
 140         // Create generic interface
 141         InterfaceBuilder otsiInterfaceBldr = createGenericInterfaceBuilder(portMap, Otsi.class,
 142             spectrumInformation.getIdentifierFromParams(logicalConnPoint));
 143
 144         // Create Interface1 type object required for adding as augmentation
 145         org.opendaylight.yang.gen.v1.http
 146                 .org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.Interface1Builder otsiIf1Builder =
 147             new org.opendaylight.yang.gen.v1.http
 148                 .org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.Interface1Builder();
 149
 150         otsiInterfaceBldr.addAugmentation(otsiIf1Builder.setOtsi(otsiBuilder.build()).build());
 151
 152         // Post interface on the device
 153         openRoadmInterfaces.postInterface(nodeId, otsiInterfaceBldr);
 154
 155         // Post the equipment-state change on the device circuit-pack if xpdr node
 156         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 157             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 158         }
 159
 160         return otsiInterfaceBldr.getName();
 161     }
 162
 163     // This is a transponder use-case where the supporting port is just one, but YANG model
 164     // requires supporting port to be list
 165     public String createOpenRoadmOtsiGroupInterface(String nodeId, String logicalConnPoint,
 166             String supportingOtsiInterface)
 167             throws OpenRoadmInterfaceException {
 168         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 169         if (portMap == null) {
 170             throw new OpenRoadmInterfaceException(
 171                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 172                     nodeId, logicalConnPoint));
 173         }
 174         // Create an OTSI group object
 175         OtsiGroupBuilder otsiGroupBuilder = new OtsiGroupBuilder()
 176             .setGroupId(Uint32.valueOf(1))
 177             .setGroupRate(R400GOtsi.class);
 178
 179         // Create generic interface
 180         InterfaceBuilder otsiGroupInterfaceBldr = createGenericInterfaceBuilder(portMap, OtsiGroup.class,
 181             logicalConnPoint + "-OTSI-GROUP");
 182
 183         // Create a list
 184         List<String> listSupportingOtsiInterface = new ArrayList<>();
 185         listSupportingOtsiInterface.add(supportingOtsiInterface);
 186         otsiGroupInterfaceBldr.setSupportingInterfaceList(listSupportingOtsiInterface);
 187
 188         org.opendaylight.yang.gen.v1.http.org.openroadm.otsi.group.interfaces.rev200529.Interface1Builder
 189                 otsiGroupIf1Builder =
 190             new org.opendaylight.yang.gen.v1.http.org.openroadm.otsi.group.interfaces.rev200529.Interface1Builder();
 191         otsiGroupInterfaceBldr.addAugmentation(otsiGroupIf1Builder.setOtsiGroup(otsiGroupBuilder.build()).build());
 192
 193         // Post interface on the device
 194         openRoadmInterfaces.postInterface(nodeId, otsiGroupInterfaceBldr);
 195
 196         // Post the equipment-state change on the device circuit-pack if xpdr node
 197         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 198             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 199         }
 200
 201         return otsiGroupInterfaceBldr.getName();
 202     }
 203
 204     public String createOpenRoadmOtucnInterface(String nodeId, String logicalConnPoint,
 205             String supportingOtsiGroupInterface)
 206             throws OpenRoadmInterfaceException {
 207         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 208         if (portMap == null) {
 209             throw new OpenRoadmInterfaceException(
 210                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 211                     nodeId, logicalConnPoint));
 212         }
 213         // Create an OTUCn object
 214         MaintLoopbackBuilder maintLoopbackBuilder = new MaintLoopbackBuilder();
 215         maintLoopbackBuilder.setEnabled(false);
 216         OtuBuilder otuBuilder = new OtuBuilder()
 217             .setRate(OTUCn.class)
 218             .setOtucnNRate(Uint16.valueOf(4))
 219             .setTimActEnabled(false)
 220             .setTimDetectMode(TimDetectMode.Disabled)
 221             .setDegmIntervals(Uint8.valueOf(2))
 222             .setDegthrPercentage(Uint16.valueOf(100))
 223             .setMaintLoopback(maintLoopbackBuilder.build());
 224
 225         InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOtu.class,
 226             logicalConnPoint + "-OTUC4");
 227
 228         // Create a list
 229         List<String> listSupportingOtsiGroupInterface = new ArrayList<>();
 230         listSupportingOtsiGroupInterface.add(supportingOtsiGroupInterface);
 231
 232         otuInterfaceBuilder.setSupportingInterfaceList(listSupportingOtsiGroupInterface);
 233         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder otuIf1Builder =
 234             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder();
 235
 236         otuInterfaceBuilder.addAugmentation(otuIf1Builder.setOtu(otuBuilder.build()).build());
 237
 238         // Post interface on the device
 239         openRoadmInterfaces.postInterface(nodeId, otuInterfaceBuilder);
 240
 241         // Post the equipment-state change on the device circuit-pack if xpdr node
 242         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 243             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 244         }
 245
 246         return otuInterfaceBuilder.getName();
 247
 248     }
 249
 250     // Adding method to have SAPI/DAPI information for the OTUCn
 251     public String createOpenRoadmOtucnInterface(String anodeId, String alogicalConnPoint,
 252             String supportingOtsiGroupInterface, String znodeId, String zlogicalConnPoint)
 253             throws OpenRoadmInterfaceException {
 254         Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
 255         Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
 256         if (portMapA == null) {
 257             throw new OpenRoadmInterfaceException(
 258                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 259                     anodeId, alogicalConnPoint));
 260         }
 261         // On the Zside
 262         if (portMapZ == null) {
 263             throw new OpenRoadmInterfaceException(
 264                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 265                     znodeId, zlogicalConnPoint));
 266
 267         }
 268         // Create an OTUCn object
 269         MaintLoopbackBuilder maintLoopbackBuilder = new MaintLoopbackBuilder();
 270         maintLoopbackBuilder.setEnabled(false);
 271         OtuBuilder otuBuilder = new OtuBuilder()
 272             .setRate(OTUCn.class)
 273             .setOtucnNRate(Uint16.valueOf(4))
 274             .setTimActEnabled(false)
 275             .setTimDetectMode(TimDetectMode.Disabled)
 276             .setDegmIntervals(Uint8.valueOf(2))
 277             .setDegthrPercentage(Uint16.valueOf(100))
 278             .setMaintLoopback(maintLoopbackBuilder.build())
 279             .setTxSapi(portMapA.getLcpHashVal())
 280             .setTxDapi(portMapZ.getLcpHashVal())
 281             // setting expected SAPI and DAPI values
 282             .setExpectedDapi(portMapA.getLcpHashVal())
 283             .setExpectedSapi(portMapZ.getLcpHashVal());
 284
 285         InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOtu.class,
 286             alogicalConnPoint + "-OTUC4");
 287
 288         // Create a list
 289         List<String> listSupportingOtsiGroupInterface = new ArrayList<>();
 290         listSupportingOtsiGroupInterface.add(supportingOtsiGroupInterface);
 291
 292         otuInterfaceBuilder.setSupportingInterfaceList(listSupportingOtsiGroupInterface);
 293         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder otuIf1Builder =
 294             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder();
 295
 296         otuInterfaceBuilder.addAugmentation(otuIf1Builder.setOtu(otuBuilder.build()).build());
 297
 298         // Post interface on the device
 299         openRoadmInterfaces.postInterface(anodeId, otuInterfaceBuilder);
 300
 301         // Post the equipment-state change on the device circuit-pack if xpdr node
 302         if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 303             this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true);
 304         }
 305
 306         return otuInterfaceBuilder.getName();
 307
 308     }
 309
 310     public String createOpenRoadmOducnInterface(String nodeId, String logicalConnPoint,
 311             String supportingOtucn)
 312             throws OpenRoadmInterfaceException {
 313         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 314         if (portMap == null) {
 315             throw new OpenRoadmInterfaceException(
 316                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 317                     nodeId, logicalConnPoint));
 318         }
 319         // Create ODUcn object
 320         // Start with OPU object
 321         // OPU payload
 322         OpuBuilder opuBuilder = new OpuBuilder()
 323             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22"))
 324             .setPayloadType(PayloadTypeDef.getDefaultInstance("22"));
 325         // Maint test signal
 326         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 327             .setTestPattern(TestPattern.PRBS23)
 328             .setEnabled(false);
 329
 330         // Create an ODUC4 object
 331         OduBuilder oduBuilder = new OduBuilder()
 332             .setRate(ODUCn.class)
 333             .setOducnNRate(Uint16.valueOf(4))
 334             .setOduFunction(ODUTTP.class)
 335             .setMonitoringMode(MonitoringMode.Terminated)
 336             .setTimActEnabled(false)
 337             .setTimDetectMode(TimDetectMode.Disabled)
 338             .setDegmIntervals(Uint8.valueOf(2))
 339             .setDegthrPercentage(Uint16.valueOf(100))
 340             .setOpu(opuBuilder.build())
 341             .setMaintTestsignal(maintTestsignal.build());
 342
 343         InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class,
 344             logicalConnPoint + "-ODUC4");
 345
 346         // Create a list
 347         List<String> listSupportingOtucnInterface = new ArrayList<>();
 348         listSupportingOtucnInterface.add(supportingOtucn);
 349
 350         oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 351         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
 352             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 353
 354         oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build());
 355
 356         // Post interface on the device
 357         openRoadmInterfaces.postInterface(nodeId, oduInterfaceBuilder);
 358
 359         // Post the equipment-state change on the device circuit-pack if xpdr node
 360         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 361             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 362         }
 363
 364         return oduInterfaceBuilder.getName();
 365     }
 366
 367     // With SAPI and DAPI information
 368     public String createOpenRoadmOducnInterface(String anodeId, String alogicalConnPoint,
 369             String supportingOtucn, String znodeId, String zlogicalConnPoint)
 370             throws OpenRoadmInterfaceException {
 371         Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
 372         Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
 373         if (portMapA == null) {
 374             throw new OpenRoadmInterfaceException(
 375                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 376                     anodeId, alogicalConnPoint));
 377         }
 378         // On the Zside
 379         if (portMapZ == null) {
 380             throw new OpenRoadmInterfaceException(
 381                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 382                     znodeId, zlogicalConnPoint));
 383
 384         }
 385         // Create ODUcn object
 386         // Start with OPU object
 387         // OPU payload
 388         OpuBuilder opuBuilder = new OpuBuilder()
 389             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22"))
 390             .setPayloadType(PayloadTypeDef.getDefaultInstance("22"));
 391         // Maint test signal
 392         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 393             .setTestPattern(TestPattern.PRBS23)
 394             .setEnabled(false);
 395
 396         // Create an ODUC4 object
 397         OduBuilder oduBuilder = new OduBuilder()
 398             .setRate(ODUCn.class)
 399             .setOducnNRate(Uint16.valueOf(4))
 400             .setOduFunction(ODUTTP.class)
 401             .setMonitoringMode(MonitoringMode.Terminated)
 402             .setTimActEnabled(false)
 403             .setTimDetectMode(TimDetectMode.Disabled)
 404             .setDegmIntervals(Uint8.valueOf(2))
 405             .setDegthrPercentage(Uint16.valueOf(100))
 406             .setOpu(opuBuilder.build())
 407             .setTxSapi(portMapA.getLcpHashVal())
 408             .setTxDapi(portMapZ.getLcpHashVal())
 409             .setExpectedSapi(portMapZ.getLcpHashVal())
 410             .setExpectedDapi(portMapZ.getLcpHashVal())
 411             .setMaintTestsignal(maintTestsignal.build());
 412
 413         InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
 414             alogicalConnPoint + "-ODUC4");
 415
 416         // Create a list
 417         List<String> listSupportingOtucnInterface = new ArrayList<>();
 418         listSupportingOtucnInterface.add(supportingOtucn);
 419
 420         oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 421         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
 422             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 423
 424         oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build());
 425
 426         // Post interface on the device
 427         openRoadmInterfaces.postInterface(anodeId, oduInterfaceBuilder);
 428
 429         // Post the equipment-state change on the device circuit-pack if xpdr node
 430         if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 431             this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true);
 432         }
 433
 434         return oduInterfaceBuilder.getName();
 435     }
 436
 437     // This is only for transponder
 438     public String createOpenRoadmOduflexInterface(String nodeId, String logicalConnPoint,
 439             String supportingOducn)
 440             throws OpenRoadmInterfaceException {
 441         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 442         if (portMap == null) {
 443             throw new OpenRoadmInterfaceException(
 444                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 445                     nodeId, logicalConnPoint));
 446         }
 447         // OPU payload
 448         OpuBuilder opuBuilder = new OpuBuilder()
 449             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("32"))
 450             .setPayloadType(PayloadTypeDef.getDefaultInstance("32"));
 451
 452         // Maint test signal
 453         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 454             .setTestPattern(TestPattern.PRBS23)
 455             .setEnabled(false);
 456
 457         // Parent Odu-allocation
 458         // Set the trib-slot array
 459         List<OpucnTribSlotDef> tribslots = new ArrayList<>();
 460         IntStream.range(1, 5).forEach(a -> IntStream.range(1, 21).forEach(b -> tribslots.add(
 461             OpucnTribSlotDef.getDefaultInstance(a + "." + b))));
 462
 463         ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
 464             .setTribPortNumber(Uint16.valueOf(1))
 465             .setTribSlotsChoice(new OpucnBuilder().setOpucnTribSlots(tribslots).build());
 466
 467         // Create an ODUFlex object
 468         OduBuilder oduBuilder = new OduBuilder()
 469             .setRate(ODUflexCbr.class)
 470             .setOduflexCbrService(ODUflexCbr400G.class)
 471             .setOduFunction(ODUTTPCTP.class)
 472             .setMonitoringMode(MonitoringMode.Terminated)
 473             .setTimActEnabled(false)
 474             .setTimDetectMode(TimDetectMode.Disabled)
 475             .setDegmIntervals(Uint8.valueOf(2))
 476             .setDegthrPercentage(Uint16.valueOf(100))
 477             .setOpu(opuBuilder.build())
 478             .setMaintTestsignal(maintTestsignal.build())
 479             .setParentOduAllocation(parentOduAllocationBuilder.build());
 480
 481         InterfaceBuilder oduflexInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class,
 482             logicalConnPoint + "-ODUFLEX");
 483
 484         List<String> listSupportingOtucnInterface = new ArrayList<>();
 485         listSupportingOtucnInterface.add(supportingOducn);
 486
 487         oduflexInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 488
 489
 490         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder
 491                 oduflexIf1Builder =
 492             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 493
 494         oduflexInterfaceBuilder.addAugmentation(oduflexIf1Builder.setOdu(oduBuilder.build()).build());
 495
 496         // Post interface on the device
 497         openRoadmInterfaces.postInterface(nodeId, oduflexInterfaceBuilder);
 498
 499         // Post the equipment-state change on the device circuit-pack if xpdr node
 500         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 501             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 502         }
 503
 504         return oduflexInterfaceBuilder.getName();
 505     }
 506
 507     // This is only for transponder; with SAPI/DAPI information
 508     public String createOpenRoadmOduflexInterface(String anodeId, String alogicalConnPoint,
 509             String supportingOducn, String znodeId, String zlogicalConnPoint)
 510             throws OpenRoadmInterfaceException {
 511         Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
 512         Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
 513         if (portMapA == null) {
 514             throw new OpenRoadmInterfaceException(
 515                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 516                     anodeId, alogicalConnPoint));
 517         }
 518         // On the Zside
 519         if (portMapZ == null) {
 520             throw new OpenRoadmInterfaceException(
 521                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 522                     znodeId, zlogicalConnPoint));
 523
 524         }
 525         // OPU payload
 526         OpuBuilder opuBuilder = new OpuBuilder()
 527             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("32"))
 528             .setPayloadType(PayloadTypeDef.getDefaultInstance("32"));
 529
 530         // Maint test signal
 531         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 532             .setTestPattern(TestPattern.PRBS23)
 533             .setEnabled(false);
 534
 535         // Parent Odu-allocation
 536         // Set the trib-slot array
 537         List<OpucnTribSlotDef> tribslots = new ArrayList<>();
 538         IntStream.range(1, 5).forEach(a -> IntStream.range(1, 21).forEach(b -> tribslots.add(
 539             OpucnTribSlotDef.getDefaultInstance(a + "." + b))));
 540
 541         ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
 542             .setTribPortNumber(Uint16.valueOf(1))
 543             .setTribSlotsChoice(new OpucnBuilder().setOpucnTribSlots(tribslots).build());
 544
 545         // Create an ODUFlex object
 546         OduBuilder oduBuilder = new OduBuilder()
 547             .setRate(ODUflexCbr.class)
 548             .setOduflexCbrService(ODUflexCbr400G.class)
 549             .setOduFunction(ODUTTPCTP.class)
 550             .setMonitoringMode(MonitoringMode.Terminated)
 551             .setTimActEnabled(false)
 552             .setTimDetectMode(TimDetectMode.Disabled)
 553             .setDegmIntervals(Uint8.valueOf(2))
 554             .setDegthrPercentage(Uint16.valueOf(100))
 555             .setTxSapi(portMapA.getLcpHashVal())
 556             .setTxDapi(portMapZ.getLcpHashVal())
 557             .setExpectedSapi(portMapZ.getLcpHashVal())
 558             .setExpectedDapi(portMapA.getLcpHashVal())
 559             .setOpu(opuBuilder.build())
 560             .setMaintTestsignal(maintTestsignal.build())
 561             .setParentOduAllocation(parentOduAllocationBuilder.build());
 562
 563         InterfaceBuilder oduflexInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
 564             alogicalConnPoint + "-ODUFLEX");
 565
 566         List<String> listSupportingOtucnInterface = new ArrayList<>();
 567         listSupportingOtucnInterface.add(supportingOducn);
 568
 569         oduflexInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 570
 571
 572         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder
 573                 oduflexIf1Builder =
 574             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 575
 576         oduflexInterfaceBuilder.addAugmentation(oduflexIf1Builder.setOdu(oduBuilder.build()).build());
 577
 578         // Post interface on the device
 579         openRoadmInterfaces.postInterface(anodeId, oduflexInterfaceBuilder);
 580
 581         // Post the equipment-state change on the device circuit-pack if xpdr node
 582         if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 583             this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true);
 584         }
 585
 586         return oduflexInterfaceBuilder.getName();
 587     }
 588
 589     // This creates the name of the interface with slot numbers at the end
 590     public String createOpenRoadmOtsiInterfaceName(String logicalConnectionPoint, String spectralSlotName) {
 591         return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotName);
 592     }
 593
 594     private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class<? extends InterfaceType> type,
 595             String key) {
 596         return new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder()
 597             .setDescription("  TBD   ")
 598             .setCircuitId("   TBD    ")
 599             .setSupportingCircuitPackName(portMap.getSupportingCircuitPackName())
 600             .setSupportingPort(portMap.getSupportingPort())
 601             .setAdministrativeState(AdminStates.InService)
 602             .setType(type)
 603             .setName(key)
 604             .withKey(new InterfaceKey(key));
 605     }
 606
 607 }