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