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