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