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