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