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 static final String ODUC4 = "-ODUC4";
  73     private final PortMapping portMapping;
  74     private final OpenRoadmInterfaces openRoadmInterfaces;
  75
  76
  77     public OpenRoadmInterface710(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) {
  78         this.portMapping = portMapping;
  79         this.openRoadmInterfaces = openRoadmInterfaces;
  80     }
  81
  82     public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
  83             throws OpenRoadmInterfaceException {
  84         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
  85         if (portMap == null) {
  86             throw new OpenRoadmInterfaceException(
  87                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
  88         }
  89
  90         // Ethernet interface specific data
  91         EthernetBuilder ethIfBuilder = new EthernetBuilder()
  92             .setFec(Rsfec.class)
  93             .setSpeed(Uint32.valueOf(400000));
  94
  95         InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.class,
  96             logicalConnPoint + "-ETHERNET");
  97         // Create Interface1 type object required for adding as augmentation
  98         Interface1Builder ethIf1Builder = new Interface1Builder();
  99         ethInterfaceBldr.addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
 100
 101         // Post interface on the device
 102         openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr);
 103
 104         // Post the equipment-state change on the device circuit-pack
 105         openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 106
 107         return ethInterfaceBldr.getName();
 108     }
 109
 110
 111     public String createOpenRoadmOtsiInterface(String nodeId, String logicalConnPoint,
 112             SpectrumInformation spectrumInformation)
 113             throws OpenRoadmInterfaceException {
 114         // TODO : Check this method
 115         ModulationFormat modulationFormat = ModulationFormat.DpQam16;
 116         Optional<ModulationFormat> optionalModulationFormat = ModulationFormat
 117             .forName(spectrumInformation.getModulationFormat());
 118         if (optionalModulationFormat.isPresent()) {
 119             modulationFormat =  optionalModulationFormat.get();
 120         }
 121         // Set the Flexo values
 122         FlexoBuilder flexoBuilder = new FlexoBuilder()
 123             .setFoicType(Foic48.class)
 124             .setIid(new ArrayList<>(Arrays.asList(Uint8.valueOf(1), Uint8.valueOf(2),
 125                 Uint8.valueOf(3), Uint8.valueOf(4))));
 126
 127         // OTSI interface specific data
 128         OtsiBuilder  otsiBuilder = new OtsiBuilder()
 129             .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency()))
 130             .setTransmitPower(new PowerDBm(new BigDecimal("-5")))
 131             .setModulationFormat(modulationFormat)
 132             .setOtsiRate(R400GOtsi.class)
 133             .setProvisionMode(ProvisionModeType.Explicit)
 134             .setFec(Ofec.class)
 135             .setFlexo(flexoBuilder.build());
 136         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 137         if (portMap == null) {
 138             throw new OpenRoadmInterfaceException(
 139                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
 140         }
 141         // Create generic interface
 142         InterfaceBuilder otsiInterfaceBldr = createGenericInterfaceBuilder(portMap, Otsi.class,
 143             spectrumInformation.getIdentifierFromParams(logicalConnPoint));
 144
 145         // Create Interface1 type object required for adding as augmentation
 146         org.opendaylight.yang.gen.v1.http
 147                 .org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.Interface1Builder otsiIf1Builder =
 148             new org.opendaylight.yang.gen.v1.http
 149                 .org.openroadm.optical.channel.tributary.signal.interfaces.rev200529.Interface1Builder();
 150
 151         otsiInterfaceBldr.addAugmentation(otsiIf1Builder.setOtsi(otsiBuilder.build()).build());
 152
 153         // Post interface on the device
 154         openRoadmInterfaces.postInterface(nodeId, otsiInterfaceBldr);
 155
 156         // Post the equipment-state change on the device circuit-pack if xpdr node
 157         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 158             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 159         }
 160
 161         return otsiInterfaceBldr.getName();
 162     }
 163
 164     // This is a transponder use-case where the supporting port is just one, but YANG model
 165     // requires supporting port to be list
 166     public String createOpenRoadmOtsiGroupInterface(String nodeId, String logicalConnPoint,
 167             String supportingOtsiInterface)
 168             throws OpenRoadmInterfaceException {
 169         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 170         if (portMap == null) {
 171             throw new OpenRoadmInterfaceException(
 172                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 173                     nodeId, logicalConnPoint));
 174         }
 175         // Create an OTSI group object
 176         OtsiGroupBuilder otsiGroupBuilder = new OtsiGroupBuilder()
 177             .setGroupId(Uint32.valueOf(1))
 178             .setGroupRate(R400GOtsi.class);
 179
 180         // Create generic interface
 181         InterfaceBuilder otsiGroupInterfaceBldr = createGenericInterfaceBuilder(portMap, OtsiGroup.class,
 182             logicalConnPoint + "-OTSI-GROUP");
 183
 184         // Create a list
 185         List<String> listSupportingOtsiInterface = new ArrayList<>();
 186         listSupportingOtsiInterface.add(supportingOtsiInterface);
 187         otsiGroupInterfaceBldr.setSupportingInterfaceList(listSupportingOtsiInterface);
 188
 189         org.opendaylight.yang.gen.v1.http.org.openroadm.otsi.group.interfaces.rev200529.Interface1Builder
 190                 otsiGroupIf1Builder =
 191             new org.opendaylight.yang.gen.v1.http.org.openroadm.otsi.group.interfaces.rev200529.Interface1Builder();
 192         otsiGroupInterfaceBldr.addAugmentation(otsiGroupIf1Builder.setOtsiGroup(otsiGroupBuilder.build()).build());
 193
 194         // Post interface on the device
 195         openRoadmInterfaces.postInterface(nodeId, otsiGroupInterfaceBldr);
 196
 197         // Post the equipment-state change on the device circuit-pack if xpdr node
 198         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 199             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 200         }
 201
 202         return otsiGroupInterfaceBldr.getName();
 203     }
 204
 205     public String createOpenRoadmOtucnInterface(String nodeId, String logicalConnPoint,
 206             String supportingOtsiGroupInterface)
 207             throws OpenRoadmInterfaceException {
 208         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 209         if (portMap == null) {
 210             throw new OpenRoadmInterfaceException(
 211                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 212                     nodeId, logicalConnPoint));
 213         }
 214         // Create an OTUCn object
 215         MaintLoopbackBuilder maintLoopbackBuilder = new MaintLoopbackBuilder();
 216         maintLoopbackBuilder.setEnabled(false);
 217         OtuBuilder otuBuilder = new OtuBuilder()
 218             .setRate(OTUCn.class)
 219             .setOtucnNRate(Uint16.valueOf(4))
 220             .setTimActEnabled(false)
 221             .setTimDetectMode(TimDetectMode.Disabled)
 222             .setDegmIntervals(Uint8.valueOf(2))
 223             .setDegthrPercentage(Uint16.valueOf(100))
 224             .setMaintLoopback(maintLoopbackBuilder.build());
 225
 226         InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOtu.class,
 227             logicalConnPoint + "-OTUC4");
 228
 229         // Create a list
 230         List<String> listSupportingOtsiGroupInterface = new ArrayList<>();
 231         listSupportingOtsiGroupInterface.add(supportingOtsiGroupInterface);
 232
 233         otuInterfaceBuilder.setSupportingInterfaceList(listSupportingOtsiGroupInterface);
 234         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder otuIf1Builder =
 235             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder();
 236
 237         otuInterfaceBuilder.addAugmentation(otuIf1Builder.setOtu(otuBuilder.build()).build());
 238
 239         // Post interface on the device
 240         openRoadmInterfaces.postInterface(nodeId, otuInterfaceBuilder);
 241
 242         // Post the equipment-state change on the device circuit-pack if xpdr node
 243         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 244             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 245         }
 246
 247         return otuInterfaceBuilder.getName();
 248
 249     }
 250
 251     // Adding method to have SAPI/DAPI information for the OTUCn
 252     public String createOpenRoadmOtucnInterface(String anodeId, String alogicalConnPoint,
 253             String supportingOtsiGroupInterface, String znodeId, String zlogicalConnPoint)
 254             throws OpenRoadmInterfaceException {
 255         Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
 256         Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
 257         if (portMapA == null) {
 258             throw new OpenRoadmInterfaceException(
 259                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 260                     anodeId, alogicalConnPoint));
 261         }
 262         // On the Zside
 263         if (portMapZ == null) {
 264             throw new OpenRoadmInterfaceException(
 265                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 266                     znodeId, zlogicalConnPoint));
 267
 268         }
 269         // Create an OTUCn object
 270         MaintLoopbackBuilder maintLoopbackBuilder = new MaintLoopbackBuilder();
 271         maintLoopbackBuilder.setEnabled(false);
 272         OtuBuilder otuBuilder = new OtuBuilder()
 273             .setRate(OTUCn.class)
 274             .setOtucnNRate(Uint16.valueOf(4))
 275             .setTimActEnabled(false)
 276             .setTimDetectMode(TimDetectMode.Disabled)
 277             .setDegmIntervals(Uint8.valueOf(2))
 278             .setDegthrPercentage(Uint16.valueOf(100))
 279             .setMaintLoopback(maintLoopbackBuilder.build())
 280             .setTxSapi(portMapA.getLcpHashVal())
 281             .setTxDapi(portMapZ.getLcpHashVal())
 282             // setting expected SAPI and DAPI values
 283             .setExpectedDapi(portMapA.getLcpHashVal())
 284             .setExpectedSapi(portMapZ.getLcpHashVal());
 285
 286         InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOtu.class,
 287             alogicalConnPoint + "-OTUC4");
 288
 289         // Create a list
 290         List<String> listSupportingOtsiGroupInterface = new ArrayList<>();
 291         listSupportingOtsiGroupInterface.add(supportingOtsiGroupInterface);
 292
 293         otuInterfaceBuilder.setSupportingInterfaceList(listSupportingOtsiGroupInterface);
 294         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder otuIf1Builder =
 295             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder();
 296
 297         otuInterfaceBuilder.addAugmentation(otuIf1Builder.setOtu(otuBuilder.build()).build());
 298
 299         // Post interface on the device
 300         openRoadmInterfaces.postInterface(anodeId, otuInterfaceBuilder);
 301
 302         // Post the equipment-state change on the device circuit-pack if xpdr node
 303         if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 304             this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true);
 305         }
 306
 307         return otuInterfaceBuilder.getName();
 308
 309     }
 310
 311     public String createOpenRoadmOducnInterface(String nodeId, String logicalConnPoint,
 312             String supportingOtucn)
 313             throws OpenRoadmInterfaceException {
 314         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 315         if (portMap == null) {
 316             throw new OpenRoadmInterfaceException(
 317                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 318                     nodeId, logicalConnPoint));
 319         }
 320         // Create ODUcn object
 321         // Start with OPU object
 322         // OPU payload
 323         OpuBuilder opuBuilder = new OpuBuilder()
 324             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22"))
 325             .setPayloadType(PayloadTypeDef.getDefaultInstance("22"));
 326         // Maint test signal
 327         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 328             // PRBS value should be PRBS31 if enabled is true
 329             .setTestPattern(TestPattern.PRBS31)
 330             .setEnabled(false);
 331
 332         // Create an ODUC4 object
 333         OduBuilder oduBuilder = new OduBuilder()
 334             .setRate(ODUCn.class)
 335             .setOducnNRate(Uint16.valueOf(4))
 336             .setOduFunction(ODUTTP.class)
 337             .setMonitoringMode(MonitoringMode.Terminated)
 338             .setTimActEnabled(false)
 339             .setTimDetectMode(TimDetectMode.Disabled)
 340             .setDegmIntervals(Uint8.valueOf(2))
 341             .setDegthrPercentage(Uint16.valueOf(100))
 342             .setOpu(opuBuilder.build())
 343             .setMaintTestsignal(maintTestsignal.build());
 344
 345         InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class,
 346             logicalConnPoint + ODUC4);
 347
 348         // Create a list
 349         List<String> listSupportingOtucnInterface = new ArrayList<>();
 350         listSupportingOtucnInterface.add(supportingOtucn);
 351
 352         oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 353         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
 354             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 355
 356         oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build());
 357
 358         // Post interface on the device
 359         openRoadmInterfaces.postInterface(nodeId, oduInterfaceBuilder);
 360
 361         // Post the equipment-state change on the device circuit-pack if xpdr node
 362         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 363             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 364         }
 365
 366         return oduInterfaceBuilder.getName();
 367     }
 368
 369     // With SAPI and DAPI information
 370     public String createOpenRoadmOducnInterface(String anodeId, String alogicalConnPoint,
 371             String supportingOtucn, String znodeId, String zlogicalConnPoint)
 372             throws OpenRoadmInterfaceException {
 373         Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
 374         Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
 375         if (portMapA == null) {
 376             throw new OpenRoadmInterfaceException(
 377                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 378                     anodeId, alogicalConnPoint));
 379         }
 380         // On the Zside
 381         if (portMapZ == null) {
 382             throw new OpenRoadmInterfaceException(
 383                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 384                     znodeId, zlogicalConnPoint));
 385
 386         }
 387         // Create ODUcn object
 388         // Start with OPU object
 389         // OPU payload
 390         OpuBuilder opuBuilder = new OpuBuilder()
 391             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22"))
 392             .setPayloadType(PayloadTypeDef.getDefaultInstance("22"));
 393         // Maint test signal
 394         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 395             // PRBS value should be PRBS31 if enabled is true
 396             .setTestPattern(TestPattern.PRBS31)
 397             .setEnabled(false);
 398
 399         // Create an ODUC4 object
 400         OduBuilder oduBuilder = new OduBuilder()
 401             .setRate(ODUCn.class)
 402             .setOducnNRate(Uint16.valueOf(4))
 403             .setOduFunction(ODUTTP.class)
 404             .setMonitoringMode(MonitoringMode.Terminated)
 405             .setTimActEnabled(false)
 406             .setTimDetectMode(TimDetectMode.Disabled)
 407             .setDegmIntervals(Uint8.valueOf(2))
 408             .setDegthrPercentage(Uint16.valueOf(100))
 409             .setOpu(opuBuilder.build())
 410             .setTxSapi(portMapA.getLcpHashVal())
 411             .setTxDapi(portMapZ.getLcpHashVal())
 412             .setExpectedSapi(portMapZ.getLcpHashVal())
 413             .setExpectedDapi(portMapZ.getLcpHashVal())
 414             .setMaintTestsignal(maintTestsignal.build());
 415
 416         InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
 417             alogicalConnPoint + ODUC4);
 418
 419         // Create a list
 420         List<String> listSupportingOtucnInterface = new ArrayList<>();
 421         listSupportingOtucnInterface.add(supportingOtucn);
 422
 423         oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 424         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
 425             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 426
 427         oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build());
 428
 429         // Post interface on the device
 430         openRoadmInterfaces.postInterface(anodeId, oduInterfaceBuilder);
 431
 432         // Post the equipment-state change on the device circuit-pack if xpdr node
 433         if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 434             this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true);
 435         }
 436
 437         return oduInterfaceBuilder.getName();
 438     }
 439
 440     public String createOpenRoadmOtnOducnInterface(String nodeId, String logicalConnPoint,
 441         String supportingOtucn)
 442         throws OpenRoadmInterfaceException {
 443         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 444         if (portMap == null) {
 445             throw new OpenRoadmInterfaceException(
 446                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 447                     nodeId, logicalConnPoint));
 448         }
 449         // Create ODUcn object
 450         // Start with OPU object
 451         // OPU payload
 452         OpuBuilder opuBuilder = new OpuBuilder()
 453             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22"))
 454             .setPayloadType(PayloadTypeDef.getDefaultInstance("22"));
 455         // Maint test signal
 456         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 457             // PRBS value should be PRBS31 if enabled is true
 458             .setTestPattern(TestPattern.PRBS31)
 459             .setEnabled(false);
 460
 461         // Create an ODUC4 object
 462         OduBuilder oduBuilder = new OduBuilder()
 463             .setRate(ODUCn.class)
 464             .setOducnNRate(Uint16.valueOf(4))
 465             .setOduFunction(ODUTTP.class)
 466             .setMonitoringMode(MonitoringMode.Terminated)
 467             .setTimActEnabled(false)
 468             .setTimDetectMode(TimDetectMode.Disabled)
 469             .setDegmIntervals(Uint8.valueOf(2))
 470             .setDegthrPercentage(Uint16.valueOf(100))
 471             .setOpu(opuBuilder.build())
 472             .setMaintTestsignal(maintTestsignal.build());
 473
 474         InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class,
 475             logicalConnPoint + ODUC4);
 476
 477         // Create a list
 478         List<String> listSupportingOtucnInterface = new ArrayList<>();
 479         listSupportingOtucnInterface.add(supportingOtucn);
 480
 481         oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 482         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
 483             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 484
 485         oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build());
 486
 487         // Post interface on the device
 488         openRoadmInterfaces.postInterface(nodeId, oduInterfaceBuilder);
 489
 490         // Post the equipment-state change on the device circuit-pack if xpdr node
 491         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 492             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 493         }
 494         // Update the port-mapping with the interface information
 495         this.portMapping.updateMapping(nodeId, portMap);
 496         return oduInterfaceBuilder.getName();
 497     }
 498
 499
 500     // With SAPI and DAPI information
 501     public String createOpenRoadmOtnOducnInterface(String anodeId, String alogicalConnPoint,
 502         String supportingOtucn, String znodeId, String zlogicalConnPoint)
 503         throws OpenRoadmInterfaceException {
 504         Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
 505         Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
 506         if (portMapA == null) {
 507             throw new OpenRoadmInterfaceException(
 508                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 509                     anodeId, alogicalConnPoint));
 510         }
 511         // On the Zside
 512         if (portMapZ == null) {
 513             throw new OpenRoadmInterfaceException(
 514                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 515                     znodeId, zlogicalConnPoint));
 516
 517         }
 518         // Create ODUcn object
 519         // Start with OPU object
 520         // OPU payload
 521         OpuBuilder opuBuilder = new OpuBuilder()
 522             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22"))
 523             .setPayloadType(PayloadTypeDef.getDefaultInstance("22"));
 524         // Maint test signal
 525         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 526             // PRBS value should be PRBS31 if enabled is true
 527             .setTestPattern(TestPattern.PRBS31)
 528             .setEnabled(false);
 529
 530         // Create an ODUC4 object
 531         OduBuilder oduBuilder = new OduBuilder()
 532             .setRate(ODUCn.class)
 533             .setOducnNRate(Uint16.valueOf(4))
 534             .setOduFunction(ODUTTP.class)
 535             .setMonitoringMode(MonitoringMode.Terminated)
 536             .setTimActEnabled(false)
 537             .setTimDetectMode(TimDetectMode.Disabled)
 538             .setDegmIntervals(Uint8.valueOf(2))
 539             .setDegthrPercentage(Uint16.valueOf(100))
 540             .setOpu(opuBuilder.build())
 541             .setTxSapi(portMapA.getLcpHashVal())
 542             .setTxDapi(portMapZ.getLcpHashVal())
 543             .setExpectedSapi(portMapZ.getLcpHashVal())
 544             .setExpectedDapi(portMapZ.getLcpHashVal())
 545             .setMaintTestsignal(maintTestsignal.build());
 546
 547         InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
 548             alogicalConnPoint + ODUC4);
 549
 550         // Create a list
 551         List<String> listSupportingOtucnInterface = new ArrayList<>();
 552         listSupportingOtucnInterface.add(supportingOtucn);
 553
 554         oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 555         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
 556             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 557
 558         oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build());
 559
 560         // Post interface on the device
 561         openRoadmInterfaces.postInterface(anodeId, oduInterfaceBuilder);
 562
 563         // Post the equipment-state change on the device circuit-pack if xpdr node
 564         if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 565             this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true);
 566         }
 567         // Update the port-mapping with the interface information
 568         this.portMapping.updateMapping(anodeId, portMapA);
 569         return oduInterfaceBuilder.getName();
 570     }
 571
 572     // This is only for transponder
 573     public String createOpenRoadmOduflexInterface(String nodeId, String logicalConnPoint,
 574             String supportingOducn)
 575             throws OpenRoadmInterfaceException {
 576         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 577         if (portMap == null) {
 578             throw new OpenRoadmInterfaceException(
 579                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 580                     nodeId, logicalConnPoint));
 581         }
 582         // OPU payload
 583         OpuBuilder opuBuilder = new OpuBuilder()
 584             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("32"))
 585             .setPayloadType(PayloadTypeDef.getDefaultInstance("32"));
 586
 587         // Maint test signal
 588         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 589             // PRBS value should be PRBS31 if enabled is true
 590             .setTestPattern(TestPattern.PRBS31)
 591             .setEnabled(false);
 592
 593         // Parent Odu-allocation
 594         // Set the trib-slot array
 595         List<OpucnTribSlotDef> tribslots = new ArrayList<>();
 596         IntStream.range(1, 5).forEach(a -> IntStream.range(1, 21).forEach(b -> tribslots.add(
 597             OpucnTribSlotDef.getDefaultInstance(a + "." + b))));
 598
 599         ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
 600             .setTribPortNumber(Uint16.valueOf(1))
 601             .setTribSlotsChoice(new OpucnBuilder().setOpucnTribSlots(tribslots).build());
 602
 603         // Create an ODUFlex object
 604         OduBuilder oduBuilder = new OduBuilder()
 605             .setRate(ODUflexCbr.class)
 606             .setOduflexCbrService(ODUflexCbr400G.class)
 607             .setOduFunction(ODUTTPCTP.class)
 608             .setMonitoringMode(MonitoringMode.Terminated)
 609             .setTimActEnabled(false)
 610             .setTimDetectMode(TimDetectMode.Disabled)
 611             .setDegmIntervals(Uint8.valueOf(2))
 612             .setDegthrPercentage(Uint16.valueOf(100))
 613             .setOpu(opuBuilder.build())
 614             .setMaintTestsignal(maintTestsignal.build())
 615             .setParentOduAllocation(parentOduAllocationBuilder.build());
 616
 617         InterfaceBuilder oduflexInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class,
 618             logicalConnPoint + "-ODUFLEX");
 619
 620         List<String> listSupportingOtucnInterface = new ArrayList<>();
 621         listSupportingOtucnInterface.add(supportingOducn);
 622
 623         oduflexInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 624
 625
 626         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder
 627                 oduflexIf1Builder =
 628             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 629
 630         oduflexInterfaceBuilder.addAugmentation(oduflexIf1Builder.setOdu(oduBuilder.build()).build());
 631
 632         // Post interface on the device
 633         openRoadmInterfaces.postInterface(nodeId, oduflexInterfaceBuilder);
 634
 635         // Post the equipment-state change on the device circuit-pack if xpdr node
 636         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 637             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 638         }
 639
 640         return oduflexInterfaceBuilder.getName();
 641     }
 642
 643     // This is only for transponder; with SAPI/DAPI information
 644     public String createOpenRoadmOduflexInterface(String anodeId, String alogicalConnPoint,
 645             String supportingOducn, String znodeId, String zlogicalConnPoint)
 646             throws OpenRoadmInterfaceException {
 647         Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
 648         Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
 649         if (portMapA == null) {
 650             throw new OpenRoadmInterfaceException(
 651                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 652                     anodeId, alogicalConnPoint));
 653         }
 654         // On the Zside
 655         if (portMapZ == null) {
 656             throw new OpenRoadmInterfaceException(
 657                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
 658                     znodeId, zlogicalConnPoint));
 659
 660         }
 661         // OPU payload
 662         OpuBuilder opuBuilder = new OpuBuilder()
 663             .setExpPayloadType(PayloadTypeDef.getDefaultInstance("32"))
 664             .setPayloadType(PayloadTypeDef.getDefaultInstance("32"));
 665
 666         // Maint test signal
 667         MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
 668             // PRBS value should be PRBS31 if enabled is true
 669             .setTestPattern(TestPattern.PRBS31)
 670             .setEnabled(false);
 671
 672         // Parent Odu-allocation
 673         // Set the trib-slot array
 674         List<OpucnTribSlotDef> tribslots = new ArrayList<>();
 675         IntStream.range(1, 5).forEach(a -> IntStream.range(1, 21).forEach(b -> tribslots.add(
 676             OpucnTribSlotDef.getDefaultInstance(a + "." + b))));
 677
 678         ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
 679             .setTribPortNumber(Uint16.valueOf(1))
 680             .setTribSlotsChoice(new OpucnBuilder().setOpucnTribSlots(tribslots).build());
 681
 682         // Create an ODUFlex object
 683         OduBuilder oduBuilder = new OduBuilder()
 684             .setRate(ODUflexCbr.class)
 685             .setOduflexCbrService(ODUflexCbr400G.class)
 686             .setOduFunction(ODUTTPCTP.class)
 687             .setMonitoringMode(MonitoringMode.Terminated)
 688             .setTimActEnabled(false)
 689             .setTimDetectMode(TimDetectMode.Disabled)
 690             .setDegmIntervals(Uint8.valueOf(2))
 691             .setDegthrPercentage(Uint16.valueOf(100))
 692             .setTxSapi(portMapA.getLcpHashVal())
 693             .setTxDapi(portMapZ.getLcpHashVal())
 694             .setExpectedSapi(portMapZ.getLcpHashVal())
 695             .setExpectedDapi(portMapA.getLcpHashVal())
 696             .setOpu(opuBuilder.build())
 697             .setMaintTestsignal(maintTestsignal.build())
 698             .setParentOduAllocation(parentOduAllocationBuilder.build());
 699
 700         InterfaceBuilder oduflexInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
 701             alogicalConnPoint + "-ODUFLEX");
 702
 703         List<String> listSupportingOtucnInterface = new ArrayList<>();
 704         listSupportingOtucnInterface.add(supportingOducn);
 705
 706         oduflexInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
 707
 708
 709         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder
 710                 oduflexIf1Builder =
 711             new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
 712
 713         oduflexInterfaceBuilder.addAugmentation(oduflexIf1Builder.setOdu(oduBuilder.build()).build());
 714
 715         // Post interface on the device
 716         openRoadmInterfaces.postInterface(anodeId, oduflexInterfaceBuilder);
 717
 718         // Post the equipment-state change on the device circuit-pack if xpdr node
 719         if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 720             this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true);
 721         }
 722
 723         return oduflexInterfaceBuilder.getName();
 724     }
 725
 726     // This creates the name of the interface with slot numbers at the end
 727     public String createOpenRoadmOtsiInterfaceName(String logicalConnectionPoint, String spectralSlotName) {
 728         return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotName);
 729     }
 730
 731     private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class<? extends InterfaceType> type,
 732             String key) {
 733         return new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder()
 734             .setDescription("  TBD   ")
 735             .setCircuitId("   TBD    ")
 736             .setSupportingCircuitPackName(portMap.getSupportingCircuitPackName())
 737             .setSupportingPort(portMap.getSupportingPort())
 738             .setAdministrativeState(AdminStates.InService)
 739             .setType(type)
 740             .setName(key)
 741             .withKey(new InterfaceKey(key));
 742     }
 743
 744 }