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