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

   1 /*
   2  * Copyright © 2017 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.util.ArrayList;
  12 import java.util.List;
  13 import java.util.Optional;
  14 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  15 import org.opendaylight.transportpce.common.StringConstants;
  16 import org.opendaylight.transportpce.common.Timeouts;
  17 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  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.rev231221.mapping.Mapping;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyGHz;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyTHz;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.ModulationFormat;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.PowerDBm;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.R100G;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.OrgOpenroadmDeviceData;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceKey;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.OrgOpenroadmDevice;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnection;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnectionKey;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnections;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.XpdrNodeTypes;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev171215.AdminStates;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.EthAttributes;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.Interface1Builder;
  43 import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.ethernet.container.EthernetBuilder;
  44 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.EthernetCsmacd;
  45 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.InterfaceType;
  46 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.MediaChannelTrailTerminationPoint;
  47 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.NetworkMediaChannelConnectionTerminationPoint;
  48 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpenROADMOpticalMultiplex;
  49 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalChannel;
  50 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalTransport;
  51 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOdu;
  52 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOtu;
  53 import org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.mc.ttp.container.McTtpBuilder;
  54 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.nmc.ctp.container.NmcCtpBuilder;
  55 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.och.container.OchBuilder;
  56 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.OtsAttributes;
  57 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.ots.container.OtsBuilder;
  58 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODU4;
  59 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUCTP;
  60 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUTTP;
  61 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUTTPCTP;
  62 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OTU4;
  63 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OduFunctionIdentity;
  64 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.PayloadTypeDef;
  65 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1;
  66 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes;
  67 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes.MonitoringMode;
  68 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.odu.container.OduBuilder;
  69 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.opu.Opu;
  70 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.opu.OpuBuilder;
  71 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.OtuAttributes;
  72 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.otu.container.OtuBuilder;
  73 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  74 import org.opendaylight.yangtools.yang.common.Decimal64;
  75 import org.opendaylight.yangtools.yang.common.Uint32;
  76 import org.slf4j.Logger;
  77 import org.slf4j.LoggerFactory;
  78
  79
  80 public class OpenRoadmInterface221 {
  81     private final PortMapping portMapping;
  82     private final OpenRoadmInterfaces openRoadmInterfaces;
  83     private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterface221.class);
  84
  85
  86     public OpenRoadmInterface221(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) {
  87         this.portMapping = portMapping;
  88         this.openRoadmInterfaces = openRoadmInterfaces;
  89     }
  90
  91     public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
  92             throws OpenRoadmInterfaceException {
  93         Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint);
  94         if (mapping == null) {
  95             throw new OpenRoadmInterfaceException(
  96                 OpenRoadmInterfaceException.mapping_msg_err(nodeId, logicalConnPoint));
  97         }
  98         // Post interface on the device
  99         InterfaceBuilder ethInterfaceBldr =
 100             createGenericInterfaceBuilder(mapping, EthernetCsmacd.VALUE, logicalConnPoint + "-ETHERNET")
 101                 .addAugmentation(
 102                     // Create Interface1 type object required for adding as augmentation
 103                     new Interface1Builder()
 104                         .setEthernet(
 105                             // Ethernet interface specific data
 106                             new EthernetBuilder()
 107                                 .setFec(EthAttributes.Fec.Off)
 108                                 .setSpeed(Uint32.valueOf(100000))
 109                                 .build())
 110                         .build());
 111         openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr);
 112         // Post the equipment-state change on the device circuit-pack
 113         openRoadmInterfaces.postEquipmentState(nodeId, mapping.getSupportingCircuitPackName(), true);
 114         this.portMapping.updateMapping(nodeId, mapping);
 115         return ethInterfaceBldr.getName();
 116     }
 117
 118     public List<String> createFlexOCH(String nodeId, String logicalConnPoint, SpectrumInformation spectrumInformation)
 119             throws OpenRoadmInterfaceException {
 120         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 121         if (portMap == null) {
 122             throw new OpenRoadmInterfaceException(
 123                 OpenRoadmInterfaceException.mapping_msg_err(nodeId, logicalConnPoint));
 124         }
 125         List<String> interfacesCreated = new ArrayList<>();
 126         String mcInterfaceCreated = "";
 127         if (logicalConnPoint.contains("DEG")) {
 128             mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, spectrumInformation);
 129             interfacesCreated.add(mcInterfaceCreated);
 130         }
 131         interfacesCreated.add(createNMCInterface(nodeId, logicalConnPoint, spectrumInformation, mcInterfaceCreated));
 132         return interfacesCreated;
 133     }
 134
 135     public String createMCInterface(String nodeId, String logicalConnPoint,
 136             SpectrumInformation spectrumInformation)
 137             throws OpenRoadmInterfaceException {
 138         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 139         if (portMap == null) {
 140             throw new OpenRoadmInterfaceException(
 141                 OpenRoadmInterfaceException.mapping_msg_err(nodeId, logicalConnPoint));
 142         }
 143         LOG.info("MC interface Freq Start {} and Freq End {} and center-Freq {}",
 144                 spectrumInformation.getMinFrequency(), spectrumInformation.getMaxFrequency(),
 145                 spectrumInformation.getCenterFrequency());
 146         InterfaceBuilder mcInterfaceBldr =
 147             createGenericInterfaceBuilder(
 148                     portMap,
 149                     MediaChannelTrailTerminationPoint.VALUE,
 150                     spectrumInformation.getIdentifierFromParams(logicalConnPoint, "mc"))
 151                 .setSupportingInterface(portMap.getSupportingOms())
 152                 .addAugmentation(
 153                     // Create Interface1 type object required for adding as augmentation
 154                     new org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019
 155                             .Interface1Builder()
 156                         .setMcTtp(
 157                             new McTtpBuilder()
 158                                 .setMinFreq(new FrequencyTHz(Decimal64.valueOf(spectrumInformation.getMinFrequency())))
 159                                 .setMaxFreq(new FrequencyTHz(Decimal64.valueOf(spectrumInformation.getMaxFrequency())))
 160                                 .build())
 161                         .build());
 162         // Post interface on the device
 163         openRoadmInterfaces.postInterface(nodeId, mcInterfaceBldr);
 164         return mcInterfaceBldr.getName();
 165     }
 166
 167     public String createNMCInterface(String nodeId, String logicalConnPoint,
 168             SpectrumInformation spectrumInformation, String mcName)
 169             throws OpenRoadmInterfaceException {
 170         LOG.info("The central frequency is {} and the nmc width is {}",
 171             spectrumInformation.getCenterFrequency(), spectrumInformation.getWidth());
 172         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 173         if (portMap == null) {
 174             throw new OpenRoadmInterfaceException(
 175                 OpenRoadmInterfaceException.mapping_msg_err(nodeId, logicalConnPoint));
 176         }
 177         InterfaceBuilder nmcInterfaceBldr =
 178             createGenericInterfaceBuilder(
 179                 portMap, NetworkMediaChannelConnectionTerminationPoint.VALUE,
 180                 spectrumInformation.getIdentifierFromParams(logicalConnPoint, "nmc"));
 181         if (logicalConnPoint.contains("DEG")) {
 182             nmcInterfaceBldr.setSupportingInterface(mcName);
 183         }
 184         // Create Interface1 type object required for adding as augmentation
 185         nmcInterfaceBldr.addAugmentation(
 186             new org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019
 187                      .Interface1Builder()
 188                 .setNmcCtp(
 189                     new NmcCtpBuilder()
 190                         .setFrequency(new FrequencyTHz(Decimal64.valueOf(spectrumInformation.getCenterFrequency())))
 191                         .setWidth(new FrequencyGHz(Decimal64.valueOf(spectrumInformation.getWidth())))
 192                         .build())
 193                 .build());
 194         // Post interface on the device
 195         openRoadmInterfaces.postInterface(nodeId, nmcInterfaceBldr);
 196         return nmcInterfaceBldr.getName();
 197     }
 198
 199     public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint,
 200             SpectrumInformation spectrumInformation)
 201             throws OpenRoadmInterfaceException {
 202         ModulationFormat modulationFormat = ModulationFormat.forName(spectrumInformation.getModulationFormat());
 203         if (modulationFormat == null) {
 204             modulationFormat = ModulationFormat.DpQpsk;
 205         }
 206         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 207         if (portMap == null) {
 208             throw new OpenRoadmInterfaceException(
 209                 OpenRoadmInterfaceException.mapping_msg_err(nodeId, logicalConnPoint));
 210         }
 211         // Create generic interface
 212         InterfaceBuilder ochInterfaceBldr =
 213             createGenericInterfaceBuilder(
 214                     portMap,
 215                     OpticalChannel.VALUE,
 216                     spectrumInformation.getIdentifierFromParams(logicalConnPoint))
 217                 .addAugmentation(
 218                     // Create Interface1 type object required for adding as augmentation
 219                     new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019
 220                             .Interface1Builder()
 221                         .setOch(
 222                             // OCH interface specific data
 223                             new OchBuilder()
 224                                 .setFrequency(
 225                                     new FrequencyTHz(Decimal64.valueOf(spectrumInformation.getCenterFrequency())))
 226                                 .setRate(R100G.VALUE)
 227                                 .setTransmitPower(new PowerDBm(Decimal64.valueOf("-5")))
 228                                 .setModulationFormat(modulationFormat)
 229                                 .build())
 230                         .build());
 231         // Post interface on the device
 232         openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr);
 233         // Post the equipment-state change on the device circuit-pack if xpdr node
 234         if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
 235             this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
 236         }
 237         return ochInterfaceBldr.getName();
 238     }
 239
 240     public String createOpenRoadmOdu4HOInterface(String nodeId, String logicalConnPoint, boolean isCTP,
 241             AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ, String payloadType) throws OpenRoadmInterfaceException {
 242         Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint);
 243         if (mapping == null) {
 244             throw new OpenRoadmInterfaceException(
 245                 OpenRoadmInterfaceException.mapping_msg_err(nodeId, logicalConnPoint));
 246         }
 247         InterfaceBuilder oduInterfaceBldr =
 248             createGenericInterfaceBuilder(mapping, OtnOdu.VALUE, logicalConnPoint + "-ODU4");
 249         if (mapping.getSupportingOtu4() != null) {
 250             oduInterfaceBldr.setSupportingInterface(mapping.getSupportingOtu4());
 251         }
 252         if (mapping.getSupportingEthernet() != null) {
 253             oduInterfaceBldr.setSupportingInterface(mapping.getSupportingEthernet());
 254         }
 255         if (isCTP) {
 256             // Create Interface1 type object required for adding as augmentation
 257             oduInterfaceBldr.addAugmentation(
 258                     createOdu4HOInterface1(ODUCTP.VALUE, MonitoringMode.Monitored, null, apiInfoA, apiInfoZ));
 259             // Post interface on the device
 260             openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
 261             return oduInterfaceBldr.getName();
 262         }
 263         // Create Interface1 type object required for adding as augmentation
 264         oduInterfaceBldr.addAugmentation(
 265                 createOdu4HOInterface1(
 266                         // For TPDR it can be both CTP and TTP - For switch-ponder we still use TTP
 267                         mapping.getXpdrType() == XpdrNodeTypes.Tpdr ? ODUTTPCTP.VALUE : ODUTTP.VALUE,
 268                         MonitoringMode.Terminated,
 269                         new OpuBuilder()
 270                                 .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
 271                                 .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
 272                                 .build(),
 273                         apiInfoA, apiInfoZ));
 274         // Post interface on the device
 275         openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
 276         LOG.info("{}-{} updating mapping with interface {}", nodeId, logicalConnPoint, oduInterfaceBldr.getName());
 277         this.portMapping.updateMapping(nodeId, mapping);
 278         return oduInterfaceBldr.getName();
 279     }
 280
 281     private Interface1 createOdu4HOInterface1(
 282             OduFunctionIdentity oduFunction, MonitoringMode monitoringMode, Opu opu,
 283             AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ) {
 284         OduBuilder oduIfBuilder = new OduBuilder()
 285                 .setRate(ODU4.VALUE)
 286                 .setOduFunction(oduFunction)
 287                 .setMonitoringMode(monitoringMode)
 288                 .setOpu(opu);
 289         if (apiInfoA != null) {
 290             oduIfBuilder.setTxSapi(apiInfoA.getSapi())
 291                 .setTxDapi(apiInfoA.getDapi())
 292                 .setExpectedSapi(apiInfoA.getExpectedSapi())
 293                 .setExpectedDapi(apiInfoA.getExpectedDapi());
 294         }
 295         if (apiInfoZ != null) {
 296             oduIfBuilder.setTxSapi(apiInfoZ.getSapi())
 297                 .setTxDapi(apiInfoZ.getDapi())
 298                 .setExpectedSapi(apiInfoZ.getExpectedSapi())
 299                 .setExpectedDapi(apiInfoZ.getExpectedDapi());
 300         }
 301         return new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder()
 302                     .setOdu(oduIfBuilder.build())
 303                     .build();
 304     }
 305
 306
 307
 308     public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
 309             throws OpenRoadmInterfaceException {
 310         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 311         if (portMap == null) {
 312             throw new OpenRoadmInterfaceException(
 313                 OpenRoadmInterfaceException.mapping_msg_err(nodeId, logicalConnPoint));
 314         }
 315         InterfaceBuilder oduInterfaceBldr =
 316             createGenericInterfaceBuilder(portMap, OtnOdu.VALUE, logicalConnPoint + "-ODU")
 317                 .setSupportingInterface(supportingOtuInterface)
 318                 .addAugmentation(
 319                     // Create Interface1 type object required for adding as augmentation
 320                     new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder()
 321                         .setOdu(
 322                             // ODU interface specific data
 323                             new OduBuilder()
 324                                 .setRate(ODU4.VALUE)
 325                                 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
 326                                 .setOpu(
 327                                     new OpuBuilder()
 328                                         .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
 329                                         .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"))
 330                                         .build())
 331                                 .build())
 332                         .build());
 333         // Post interface on the device
 334         openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
 335         return oduInterfaceBldr.getName();
 336     }
 337
 338     public String createOpenRoadmOdu4Interface(String anodeId, String alogicalConnPoint, String supportingOtuInterface,
 339             String znodeId, String zlogicalConnPoint)
 340             throws OpenRoadmInterfaceException {
 341         Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
 342         Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
 343         if (portMapA == null) {
 344             throw new OpenRoadmInterfaceException(
 345                 OpenRoadmInterfaceException.mapping_msg_err(anodeId, alogicalConnPoint));
 346         }
 347         if (portMapZ == null) {
 348             throw new OpenRoadmInterfaceException(
 349                 OpenRoadmInterfaceException.mapping_msg_err(znodeId, zlogicalConnPoint));
 350         }
 351         InterfaceBuilder oduInterfaceBldr =
 352             createGenericInterfaceBuilder(portMapA, OtnOdu.VALUE, alogicalConnPoint + "-ODU")
 353                 .setSupportingInterface(supportingOtuInterface)
 354                 .addAugmentation(
 355                     // Create Interface1 type object required for adding as augmentation
 356                     new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder()
 357                         .setOdu(
 358                             new OduBuilder()
 359                                 .setRate(ODU4.VALUE)
 360                                 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
 361                                 .setOpu(
 362                                     // ODU interface specific data
 363                                     // Set Opu attributes
 364                                     new OpuBuilder()
 365                                         .setPayloadType(PayloadTypeDef.getDefaultInstance("07"))
 366                                         .setExpPayloadType(PayloadTypeDef.getDefaultInstance("07"))
 367                                         .build())
 368                                 .setTxSapi(portMapA.getLcpHashVal())
 369                                 .setTxDapi(portMapZ.getLcpHashVal())
 370                                 // Setting the expected Dapi and Sapi values
 371                                 .setExpectedDapi(portMapA.getLcpHashVal())
 372                                 .setExpectedSapi(portMapZ.getLcpHashVal())
 373                                 .build())
 374                         .build());
 375         // Post interface on the device
 376         openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
 377         return oduInterfaceBldr.getName();
 378     }
 379
 380     public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface,
 381             AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ) throws OpenRoadmInterfaceException {
 382         Mapping mapping = this.portMapping.getMapping(nodeId, logicalConnPoint);
 383         if (mapping == null) {
 384             throw new OpenRoadmInterfaceException(
 385                 OpenRoadmInterfaceException.mapping_msg_err(nodeId, logicalConnPoint));
 386         }
 387         // OTU interface specific data
 388         OtuBuilder otuIfBuilder = new OtuBuilder()
 389             .setFec(OtuAttributes.Fec.Scfec)
 390             .setRate(OTU4.VALUE);
 391         if (apiInfoA != null) {
 392             otuIfBuilder.setTxSapi(apiInfoA.getSapi())
 393                 .setTxDapi(apiInfoA.getDapi())
 394                 .setExpectedSapi(apiInfoA.getExpectedSapi())
 395                 .setExpectedDapi(apiInfoA.getExpectedDapi());
 396         }
 397         if (apiInfoZ != null) {
 398             otuIfBuilder.setTxSapi(apiInfoZ.getSapi())
 399                 .setTxDapi(apiInfoZ.getDapi())
 400                 .setExpectedSapi(apiInfoZ.getExpectedSapi())
 401                 .setExpectedDapi(apiInfoZ.getExpectedDapi());
 402         }
 403         InterfaceBuilder otuInterfaceBldr =
 404             createGenericInterfaceBuilder(mapping, OtnOtu.VALUE, logicalConnPoint + "-OTU")
 405                 .setSupportingInterface(supportOchInterface)
 406                 .addAugmentation(
 407                     // Create Interface1 type object required for adding as augmentation
 408                     new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder()
 409                         .setOtu(otuIfBuilder.build())
 410                         .build());
 411         // Post interface on the device
 412         openRoadmInterfaces.postInterface(nodeId, otuInterfaceBldr);
 413         this.portMapping.updateMapping(nodeId, mapping);
 414         return otuInterfaceBldr.getName();
 415     }
 416
 417     public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, String spectralSlotName) {
 418         return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotName);
 419     }
 420
 421     private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, InterfaceType type, String key) {
 422         return new InterfaceBuilder()
 423                 .setDescription("  TBD   ")
 424                 .setCircuitId("   TBD    ")
 425                 .setSupportingCircuitPackName(portMap.getSupportingCircuitPackName())
 426                 .setSupportingPort(portMap.getSupportingPort())
 427                 .setAdministrativeState(AdminStates.InService)
 428                 .setType(type)
 429                 .setName(key)
 430                 .withKey(new InterfaceKey(key));
 431     }
 432
 433     public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
 434         if (mapping.getSupportingOms() != null) {
 435             return mapping.getSupportingOms();
 436         }
 437         // Create generic interface
 438         if (mapping.getSupportingOts() == null) {
 439             LOG.error("Unable to get ots interface from mapping {} - {}", nodeId, mapping.getLogicalConnectionPoint());
 440             return null;
 441         }
 442         InterfaceBuilder omsInterfaceBldr =
 443             createGenericInterfaceBuilder(
 444                     mapping, OpenROADMOpticalMultiplex.VALUE, "OMS-" + mapping.getLogicalConnectionPoint())
 445                 .setSupportingInterface(mapping.getSupportingOts());
 446         this.openRoadmInterfaces.postInterface(nodeId, omsInterfaceBldr);
 447         this.portMapping.updateMapping(nodeId, mapping);
 448         return omsInterfaceBldr.build().getName();
 449     }
 450
 451     public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
 452         if (mapping.getSupportingOts() != null) {
 453             return mapping.getSupportingOts();
 454         }
 455         // Create generic interface
 456         InterfaceBuilder otsInterfaceBldr =
 457             createGenericInterfaceBuilder(mapping, OpticalTransport.VALUE, "OTS-" + mapping.getLogicalConnectionPoint())
 458                 .addAugmentation(
 459                     // Create Interface1 type object required for adding as augmentation
 460                     new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019
 461                             .Interface1Builder()
 462                         // OTS interface augmentation specific data
 463                         .setOts(new OtsBuilder().setFiberType(OtsAttributes.FiberType.Smf).build())
 464                         .build());
 465         this.openRoadmInterfaces.postInterface(nodeId, otsInterfaceBldr);
 466         this.portMapping.updateMapping(nodeId, mapping);
 467         return otsInterfaceBldr.build().getName();
 468     }
 469
 470     public boolean isUsedByXc(String nodeId, String interfaceName, String xc,
 471         DeviceTransactionManager deviceTransactionManager) {
 472         InstanceIdentifier<RoadmConnections> xciid = InstanceIdentifier
 473             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 474             .child(RoadmConnections.class, new RoadmConnectionsKey(xc))
 475             .build();
 476         LOG.info("reading xc {} in node {}", xc, nodeId);
 477         Optional<RoadmConnections> crossconnection = deviceTransactionManager.getDataFromDevice(nodeId,
 478             LogicalDatastoreType.CONFIGURATION, xciid, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 479         if (crossconnection.isEmpty()) {
 480             LOG.info("xd {} not found !", xc);
 481             return false;
 482         }
 483         RoadmConnections rc = crossconnection.orElseThrow();
 484         LOG.info("xd {} found", xc);
 485         String supportedinter =
 486             interfaceName.contains("nmc")
 487                 ? null
 488                 : interfaceName.replace("mc", "nmc");
 489         if (rc.getSource().getSrcIf().equals(interfaceName)
 490                 || rc.getDestination().getDstIf().equals(interfaceName)
 491                 || rc.getSource().getSrcIf().equals(supportedinter)
 492                 || rc.getDestination().getDstIf().equals(supportedinter)) {
 493             return true;
 494         }
 495         return false;
 496     }
 497
 498     public boolean isUsedByOtnXc(String nodeId, String interfaceName, String xc,
 499             DeviceTransactionManager deviceTransactionManager) {
 500         InstanceIdentifier<OduConnection> xciid = InstanceIdentifier
 501             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 502             .child(OduConnection.class, new OduConnectionKey(xc))
 503             .build();
 504         LOG.info("reading xc {} in node {}", xc, nodeId);
 505         Optional<OduConnection> oduConnectionOpt = deviceTransactionManager.getDataFromDevice(nodeId,
 506             LogicalDatastoreType.CONFIGURATION, xciid, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 507         if (oduConnectionOpt.isEmpty()) {
 508             LOG.info("xc {} not found !", xc);
 509             return false;
 510         }
 511         OduConnection oduXc = oduConnectionOpt.orElseThrow();
 512         LOG.info("xc {} found", xc);
 513         if (oduXc.getSource().getSrcIf().equals(interfaceName)
 514                 || oduXc.getDestination().getDstIf().equals(interfaceName)) {
 515             return true;
 516         }
 517         return false;
 518     }
 519
 520     public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
 521             throws OpenRoadmInterfaceException {
 522         Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
 523         if (portMap == null) {
 524             throw new OpenRoadmInterfaceException(
 525                 OpenRoadmInterfaceException.mapping_msg_err(nodeId, logicalConnPoint));
 526         }
 527         InterfaceBuilder oduInterfaceBldr =
 528             createGenericInterfaceBuilder(portMap, OtnOdu.VALUE, logicalConnPoint + "-ODU4")
 529                 .setSupportingInterface(supportingOtuInterface)
 530                 .addAugmentation(
 531                 // Create Interface1 type object required for adding as augmentation
 532                     new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder()
 533                         .setOdu(
 534                         // ODU interface specific data
 535                             new OduBuilder()
 536                                 .setRate(ODU4.VALUE)
 537                                 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
 538                                 .setOduFunction(ODUTTP.VALUE)
 539                                 .setOpu(
 540                                     // Set Opu attributes
 541                                     new OpuBuilder()
 542                                         .setPayloadType(PayloadTypeDef.getDefaultInstance("21"))
 543                                         .setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"))
 544                                         .build()
 545                                 )
 546                                 .build())
 547                         .build());
 548         // Post interface on the device
 549         openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
 550         this.portMapping.updateMapping(nodeId, portMap);
 551         return oduInterfaceBldr.getName();
 552     }
 553
 554     public String createOpenRoadmOtnOdu4Interface(String anodeId, String alogicalConnPoint,
 555             String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)
 556             throws OpenRoadmInterfaceException {
 557         Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
 558         if (portMapA == null) {
 559             throw new OpenRoadmInterfaceException(
 560                 OpenRoadmInterfaceException.mapping_msg_err(anodeId, alogicalConnPoint));
 561         }
 562         Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
 563         if (portMapZ == null) {
 564             throw new OpenRoadmInterfaceException(
 565                 OpenRoadmInterfaceException.mapping_msg_err(znodeId, zlogicalConnPoint));
 566         }
 567         InterfaceBuilder oduInterfaceBldr =
 568             createGenericInterfaceBuilder(portMapA, OtnOdu.VALUE, alogicalConnPoint + "-ODU4")
 569                 .setSupportingInterface(asupportingOtuInterface)
 570                 .addAugmentation(
 571                     // Create Interface1 type object required for adding as augmentation
 572                     new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019
 573                             .Interface1Builder()
 574                         .setOdu(
 575                         // ODU interface specific data
 576                             new OduBuilder()
 577                                 .setRate(ODU4.VALUE)
 578                                 .setMonitoringMode(OduAttributes.MonitoringMode.Terminated)
 579                                 .setTxSapi(portMapA.getLcpHashVal())
 580                                 .setTxDapi(portMapZ.getLcpHashVal())
 581                                 .setExpectedSapi(portMapZ.getLcpHashVal())
 582                                 .setExpectedDapi(portMapA.getLcpHashVal())
 583                                 .setOduFunction(ODUTTP.VALUE)
 584                                 .setOpu(
 585                                     // Set Opu attributes
 586                                     new OpuBuilder()
 587                                         .setPayloadType(PayloadTypeDef.getDefaultInstance("21"))
 588                                         .setExpPayloadType(PayloadTypeDef.getDefaultInstance("21"))
 589                                         .build())
 590                                 .build())
 591                         .build());
 592         // Post interface on the device
 593         openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
 594         this.portMapping.updateMapping(anodeId, portMapA);
 595         return oduInterfaceBldr.getName();
 596     }
 597 }