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