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