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.rev210426.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             // PRBS value should be PRBS31 if enabled is true
 328             .setTestPattern(TestPattern.PRBS31)
 329             .setEnabled(false);
 330
 331         // Create an ODUC4 object
 332         OduBuilder oduBuilder = new OduBuilder()
 333             .setRate(ODUCn.class)
 334             .setOducnNRate(Uint16.valueOf(4))
 335             .setOduFunction(ODUTTP.class)
 336             .setMonitoringMode(MonitoringMode.Terminated)
 337             .setTimActEnabled(false)
 338             .setTimDetectMode(TimDetectMode.Disabled)
 339             .setDegmIntervals(Uint8.valueOf(2))
 340             .setDegthrPercentage(Uint16.valueOf(100))
 341             .setOpu(opuBuilder.build())
 342             .setMaintTestsignal(maintTestsignal.build());
 343
 344         InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class,
 345             logicalConnPoint + "-ODUC4");
 346
 347         // Create a list
 348         List<String> listSupportingOtucnInterface = new ArrayList<>();
 349         listSupportingOtucnInterface.add(supportingOtucn);
 350
 351         oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 352         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
 353             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 354
 355         oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build());
 356
 357         // Post interface on the device
 358         openRoadmInterfaces.postInterface(nodeId, oduInterfaceBuilder);
 359
 360         // Post the equipment-state change on the device circuit-pack if xpdr node
 361         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 362             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 363         }
 364
 365         return oduInterfaceBuilder.getName();
 366     }
 367
 368     // With SAPI and DAPI information
 369     public String createOpenRoadmOducnInterface(String anodeId, String alogicalConnPoint,
 370             String supportingOtucn, String znodeId, String zlogicalConnPoint)
 371             throws OpenRoadmInterfaceException {
 372         Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
 373         Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
 374         if (portMapA == null) {
 375             throw new OpenRoadmInterfaceException(
 376                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 377                     anodeId, alogicalConnPoint));
 378         }
 379         // On the Zside
 380         if (portMapZ == null) {
 381             throw new OpenRoadmInterfaceException(
 382                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 383                     znodeId, zlogicalConnPoint));
 384
 385         }
 386         // Create ODUcn object
 387         // Start with OPU object
 388         // OPU payload
 389         OpuBuilder opuBuilder = new OpuBuilder()
 390             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22"))
 391             .setPayloadType(PayloadTypeDef.getDefaultInstance("22"));
 392         // Maint test signal
 393         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 394             // PRBS value should be PRBS31 if enabled is true
 395             .setTestPattern(TestPattern.PRBS31)
 396             .setEnabled(false);
 397
 398         // Create an ODUC4 object
 399         OduBuilder oduBuilder = new OduBuilder()
 400             .setRate(ODUCn.class)
 401             .setOducnNRate(Uint16.valueOf(4))
 402             .setOduFunction(ODUTTP.class)
 403             .setMonitoringMode(MonitoringMode.Terminated)
 404             .setTimActEnabled(false)
 405             .setTimDetectMode(TimDetectMode.Disabled)
 406             .setDegmIntervals(Uint8.valueOf(2))
 407             .setDegthrPercentage(Uint16.valueOf(100))
 408             .setOpu(opuBuilder.build())
 409             .setTxSapi(portMapA.getLcpHashVal())
 410             .setTxDapi(portMapZ.getLcpHashVal())
 411             .setExpectedSapi(portMapZ.getLcpHashVal())
 412             .setExpectedDapi(portMapZ.getLcpHashVal())
 413             .setMaintTestsignal(maintTestsignal.build());
 414
 415         InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
 416             alogicalConnPoint + "-ODUC4");
 417
 418         // Create a list
 419         List<String> listSupportingOtucnInterface = new ArrayList<>();
 420         listSupportingOtucnInterface.add(supportingOtucn);
 421
 422         oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 423         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
 424             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 425
 426         oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build());
 427
 428         // Post interface on the device
 429         openRoadmInterfaces.postInterface(anodeId, oduInterfaceBuilder);
 430
 431         // Post the equipment-state change on the device circuit-pack if xpdr node
 432         if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 433             this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true);
 434         }
 435
 436         return oduInterfaceBuilder.getName();
 437     }
 438
 439     public String createOpenRoadmOtnOducnInterface(String nodeId, String logicalConnPoint,
 440         String supportingOtucn)
 441         throws OpenRoadmInterfaceException {
 442         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 443         if (portMap == null) {
 444             throw new OpenRoadmInterfaceException(
 445                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 446                     nodeId, logicalConnPoint));
 447         }
 448         // Create ODUcn object
 449         // Start with OPU object
 450         // OPU payload
 451         OpuBuilder opuBuilder = new OpuBuilder()
 452             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22"))
 453             .setPayloadType(PayloadTypeDef.getDefaultInstance("22"));
 454         // Maint test signal
 455         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 456             // PRBS value should be PRBS31 if enabled is true
 457             .setTestPattern(TestPattern.PRBS31)
 458             .setEnabled(false);
 459
 460         // Create an ODUC4 object
 461         OduBuilder oduBuilder = new OduBuilder()
 462             .setRate(ODUCn.class)
 463             .setOducnNRate(Uint16.valueOf(4))
 464             .setOduFunction(ODUTTP.class)
 465             .setMonitoringMode(MonitoringMode.Terminated)
 466             .setTimActEnabled(false)
 467             .setTimDetectMode(TimDetectMode.Disabled)
 468             .setDegmIntervals(Uint8.valueOf(2))
 469             .setDegthrPercentage(Uint16.valueOf(100))
 470             .setOpu(opuBuilder.build())
 471             .setMaintTestsignal(maintTestsignal.build());
 472
 473         InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class,
 474             logicalConnPoint + "-ODUC4");
 475
 476         // Create a list
 477         List<String> listSupportingOtucnInterface = new ArrayList<>();
 478         listSupportingOtucnInterface.add(supportingOtucn);
 479
 480         oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 481         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
 482             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 483
 484         oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build());
 485
 486         // Post interface on the device
 487         openRoadmInterfaces.postInterface(nodeId, oduInterfaceBuilder);
 488
 489         // Post the equipment-state change on the device circuit-pack if xpdr node
 490         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 491             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 492         }
 493         // Update the port-mapping with the interface information
 494         this.portMapping.updateMapping(nodeId, portMap);
 495         return oduInterfaceBuilder.getName();
 496     }
 497
 498
 499     // With SAPI and DAPI information
 500     public String createOpenRoadmOtnOducnInterface(String anodeId, String alogicalConnPoint,
 501         String supportingOtucn, String znodeId, String zlogicalConnPoint)
 502         throws OpenRoadmInterfaceException {
 503         Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
 504         Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
 505         if (portMapA == null) {
 506             throw new OpenRoadmInterfaceException(
 507                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 508                     anodeId, alogicalConnPoint));
 509         }
 510         // On the Zside
 511         if (portMapZ == null) {
 512             throw new OpenRoadmInterfaceException(
 513                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 514                     znodeId, zlogicalConnPoint));
 515
 516         }
 517         // Create ODUcn object
 518         // Start with OPU object
 519         // OPU payload
 520         OpuBuilder opuBuilder = new OpuBuilder()
 521             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22"))
 522             .setPayloadType(PayloadTypeDef.getDefaultInstance("22"));
 523         // Maint test signal
 524         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 525             // PRBS value should be PRBS31 if enabled is true
 526             .setTestPattern(TestPattern.PRBS31)
 527             .setEnabled(false);
 528
 529         // Create an ODUC4 object
 530         OduBuilder oduBuilder = new OduBuilder()
 531             .setRate(ODUCn.class)
 532             .setOducnNRate(Uint16.valueOf(4))
 533             .setOduFunction(ODUTTP.class)
 534             .setMonitoringMode(MonitoringMode.Terminated)
 535             .setTimActEnabled(false)
 536             .setTimDetectMode(TimDetectMode.Disabled)
 537             .setDegmIntervals(Uint8.valueOf(2))
 538             .setDegthrPercentage(Uint16.valueOf(100))
 539             .setOpu(opuBuilder.build())
 540             .setTxSapi(portMapA.getLcpHashVal())
 541             .setTxDapi(portMapZ.getLcpHashVal())
 542             .setExpectedSapi(portMapZ.getLcpHashVal())
 543             .setExpectedDapi(portMapZ.getLcpHashVal())
 544             .setMaintTestsignal(maintTestsignal.build());
 545
 546         InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
 547             alogicalConnPoint + "-ODUC4");
 548
 549         // Create a list
 550         List<String> listSupportingOtucnInterface = new ArrayList<>();
 551         listSupportingOtucnInterface.add(supportingOtucn);
 552
 553         oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 554         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
 555             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 556
 557         oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build());
 558
 559         // Post interface on the device
 560         openRoadmInterfaces.postInterface(anodeId, oduInterfaceBuilder);
 561
 562         // Post the equipment-state change on the device circuit-pack if xpdr node
 563         if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 564             this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true);
 565         }
 566         // Update the port-mapping with the interface information
 567         this.portMapping.updateMapping(anodeId, portMapA);
 568         return oduInterfaceBuilder.getName();
 569     }
 570
 571     // This is only for transponder
 572     public String createOpenRoadmOduflexInterface(String nodeId, String logicalConnPoint,
 573             String supportingOducn)
 574             throws OpenRoadmInterfaceException {
 575         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 576         if (portMap == null) {
 577             throw new OpenRoadmInterfaceException(
 578                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 579                     nodeId, logicalConnPoint));
 580         }
 581         // OPU payload
 582         OpuBuilder opuBuilder = new OpuBuilder()
 583             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("32"))
 584             .setPayloadType(PayloadTypeDef.getDefaultInstance("32"));
 585
 586         // Maint test signal
 587         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 588             // PRBS value should be PRBS31 if enabled is true
 589             .setTestPattern(TestPattern.PRBS31)
 590             .setEnabled(false);
 591
 592         // Parent Odu-allocation
 593         // Set the trib-slot array
 594         List<OpucnTribSlotDef> tribslots = new ArrayList<>();
 595         IntStream.range(1, 5).forEach(a -> IntStream.range(1, 21).forEach(b -> tribslots.add(
 596             OpucnTribSlotDef.getDefaultInstance(a + "." + b))));
 597
 598         ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
 599             .setTribPortNumber(Uint16.valueOf(1))
 600             .setTribSlotsChoice(new OpucnBuilder().setOpucnTribSlots(tribslots).build());
 601
 602         // Create an ODUFlex object
 603         OduBuilder oduBuilder = new OduBuilder()
 604             .setRate(ODUflexCbr.class)
 605             .setOduflexCbrService(ODUflexCbr400G.class)
 606             .setOduFunction(ODUTTPCTP.class)
 607             .setMonitoringMode(MonitoringMode.Terminated)
 608             .setTimActEnabled(false)
 609             .setTimDetectMode(TimDetectMode.Disabled)
 610             .setDegmIntervals(Uint8.valueOf(2))
 611             .setDegthrPercentage(Uint16.valueOf(100))
 612             .setOpu(opuBuilder.build())
 613             .setMaintTestsignal(maintTestsignal.build())
 614             .setParentOduAllocation(parentOduAllocationBuilder.build());
 615
 616         InterfaceBuilder oduflexInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class,
 617             logicalConnPoint + "-ODUFLEX");
 618
 619         List<String> listSupportingOtucnInterface = new ArrayList<>();
 620         listSupportingOtucnInterface.add(supportingOducn);
 621
 622         oduflexInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 623
 624
 625         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder
 626                 oduflexIf1Builder =
 627             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 628
 629         oduflexInterfaceBuilder.addAugmentation(oduflexIf1Builder.setOdu(oduBuilder.build()).build());
 630
 631         // Post interface on the device
 632         openRoadmInterfaces.postInterface(nodeId, oduflexInterfaceBuilder);
 633
 634         // Post the equipment-state change on the device circuit-pack if xpdr node
 635         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 636             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 637         }
 638
 639         return oduflexInterfaceBuilder.getName();
 640     }
 641
 642     // This is only for transponder; with SAPI/DAPI information
 643     public String createOpenRoadmOduflexInterface(String anodeId, String alogicalConnPoint,
 644             String supportingOducn, String znodeId, String zlogicalConnPoint)
 645             throws OpenRoadmInterfaceException {
 646         Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
 647         Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
 648         if (portMapA == null) {
 649             throw new OpenRoadmInterfaceException(
 650                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 651                     anodeId, alogicalConnPoint));
 652         }
 653         // On the Zside
 654         if (portMapZ == null) {
 655             throw new OpenRoadmInterfaceException(
 656                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 657                     znodeId, zlogicalConnPoint));
 658
 659         }
 660         // OPU payload
 661         OpuBuilder opuBuilder = new OpuBuilder()
 662             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("32"))
 663             .setPayloadType(PayloadTypeDef.getDefaultInstance("32"));
 664
 665         // Maint test signal
 666         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 667             // PRBS value should be PRBS31 if enabled is true
 668             .setTestPattern(TestPattern.PRBS31)
 669             .setEnabled(false);
 670
 671         // Parent Odu-allocation
 672         // Set the trib-slot array
 673         List<OpucnTribSlotDef> tribslots = new ArrayList<>();
 674         IntStream.range(1, 5).forEach(a -> IntStream.range(1, 21).forEach(b -> tribslots.add(
 675             OpucnTribSlotDef.getDefaultInstance(a + "." + b))));
 676
 677         ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
 678             .setTribPortNumber(Uint16.valueOf(1))
 679             .setTribSlotsChoice(new OpucnBuilder().setOpucnTribSlots(tribslots).build());
 680
 681         // Create an ODUFlex object
 682         OduBuilder oduBuilder = new OduBuilder()
 683             .setRate(ODUflexCbr.class)
 684             .setOduflexCbrService(ODUflexCbr400G.class)
 685             .setOduFunction(ODUTTPCTP.class)
 686             .setMonitoringMode(MonitoringMode.Terminated)
 687             .setTimActEnabled(false)
 688             .setTimDetectMode(TimDetectMode.Disabled)
 689             .setDegmIntervals(Uint8.valueOf(2))
 690             .setDegthrPercentage(Uint16.valueOf(100))
 691             .setTxSapi(portMapA.getLcpHashVal())
 692             .setTxDapi(portMapZ.getLcpHashVal())
 693             .setExpectedSapi(portMapZ.getLcpHashVal())
 694             .setExpectedDapi(portMapA.getLcpHashVal())
 695             .setOpu(opuBuilder.build())
 696             .setMaintTestsignal(maintTestsignal.build())
 697             .setParentOduAllocation(parentOduAllocationBuilder.build());
 698
 699         InterfaceBuilder oduflexInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
 700             alogicalConnPoint + "-ODUFLEX");
 701
 702         List<String> listSupportingOtucnInterface = new ArrayList<>();
 703         listSupportingOtucnInterface.add(supportingOducn);
 704
 705         oduflexInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 706
 707
 708         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder
 709                 oduflexIf1Builder =
 710             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 711
 712         oduflexInterfaceBuilder.addAugmentation(oduflexIf1Builder.setOdu(oduBuilder.build()).build());
 713
 714         // Post interface on the device
 715         openRoadmInterfaces.postInterface(anodeId, oduflexInterfaceBuilder);
 716
 717         // Post the equipment-state change on the device circuit-pack if xpdr node
 718         if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 719             this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true);
 720         }
 721
 722         return oduflexInterfaceBuilder.getName();
 723     }
 724
 725     // This creates the name of the interface with slot numbers at the end
 726     public String createOpenRoadmOtsiInterfaceName(String logicalConnectionPoint, String spectralSlotName) {
 727         return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotName);
 728     }
 729
 730     private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class<? extends InterfaceType> type,
 731             String key) {
 732         return new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder()
 733             .setDescription("  TBD   ")
 734             .setCircuitId("   TBD    ")
 735             .setSupportingCircuitPackName(portMap.getSupportingCircuitPackName())
 736             .setSupportingPort(portMap.getSupportingPort())
 737             .setAdministrativeState(AdminStates.InService)
 738             .setType(type)
 739             .setName(key)
 740             .withKey(new InterfaceKey(key));
 741     }
 742
 743 }