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