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