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