renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterfaceFactory.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.List;
  12 import org.opendaylight.transportpce.common.StringConstants;
  13 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  14 import org.opendaylight.transportpce.common.fixedflex.GridConstant;
  15 import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
  16 import org.opendaylight.transportpce.common.mapping.MappingUtils;
  17 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
  18 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.Mapping;
  19 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef;
  20 import org.slf4j.Logger;
  21 import org.slf4j.LoggerFactory;
  22
  23 public class OpenRoadmInterfaceFactory {
  24
  25     private static final String OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG =
  26             "OTN functions are not supported by Openroadm models 1.2.1";
  27     private static  final String OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_2_2_1_MSG =
  28             "OTN functions are not supported by Openroadm models 2.2.1";
  29     private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaceFactory.class);
  30     private final MappingUtils mappingUtils;
  31     private final OpenRoadmInterface121 openRoadmInterface121;
  32     private final OpenRoadmInterface221 openRoadmInterface221;
  33     private final OpenRoadmInterface710 openRoadmInterface710;
  34     private final OpenRoadmOtnInterface221 openRoadmOtnInterface221;
  35     private final OpenRoadmOtnInterface710 openRoadmOtnInterface710;
  36
  37     public OpenRoadmInterfaceFactory(MappingUtils mappingUtils, OpenRoadmInterface121 openRoadmInterface121,
  38             OpenRoadmInterface221 openRoadmInterface221, OpenRoadmInterface710 openRoadmInterface710,
  39             OpenRoadmOtnInterface221 openRoadmOTNInterface221, OpenRoadmOtnInterface710 openRoadmOtnInterface710) {
  40         this.mappingUtils = mappingUtils;
  41         this.openRoadmInterface121 = openRoadmInterface121;
  42         this.openRoadmInterface221 = openRoadmInterface221;
  43         this.openRoadmInterface710 = openRoadmInterface710;
  44         this.openRoadmOtnInterface221 = openRoadmOTNInterface221;
  45         this.openRoadmOtnInterface710 = openRoadmOtnInterface710;
  46     }
  47
  48     public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
  49             throws OpenRoadmInterfaceException {
  50
  51         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
  52             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
  53                 return openRoadmInterface121.createOpenRoadmEthInterface(nodeId, logicalConnPoint);
  54             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
  55                 return openRoadmInterface221.createOpenRoadmEthInterface(nodeId, logicalConnPoint);
  56             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
  57                 return openRoadmInterface710.createOpenRoadmEthInterface(nodeId, logicalConnPoint);
  58             default:
  59                 return null;
  60         }
  61     }
  62
  63     public List<String> createOpenRoadmOchInterfaces(String nodeId, String logicalConnPoint,
  64             SpectrumInformation spectrumInformation)
  65             throws OpenRoadmInterfaceException {
  66         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
  67             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
  68                 return openRoadmInterface121.createOpenRoadmOchInterfaces(nodeId, logicalConnPoint,
  69                         spectrumInformation);
  70             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
  71                 return openRoadmInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation);
  72             default:
  73                 return null;
  74         }
  75     }
  76
  77
  78     /**
  79      * This methods creates an OCH interface on the given termination point on Roadm.
  80      *
  81      * @param nodeId           node ID
  82      * @param logicalConnPoint logical connection point
  83      * @param spectrumInformation spectrum information.
  84      * @return Name of the interface if successful, otherwise return null.
  85      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
  86      */
  87     public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint,
  88             SpectrumInformation spectrumInformation) throws OpenRoadmInterfaceException {
  89         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
  90             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
  91                 return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint,
  92                         spectrumInformation);
  93             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
  94                 return openRoadmInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint,
  95                         spectrumInformation);
  96             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
  97                 // In the case of 710 device, we logically combine the OTSi and OTSiGroup interface and represent
  98                 // as OCh
  99                 String interfaceOtsiName = openRoadmInterface710.createOpenRoadmOtsiInterface(nodeId, logicalConnPoint,
 100                     spectrumInformation);
 101                 return openRoadmInterface710.createOpenRoadmOtsiGroupInterface(nodeId, logicalConnPoint,
 102                     interfaceOtsiName);
 103             default:
 104                 return null;
 105         }
 106     }
 107
 108     /**
 109      * This methods creates an ODU interface on the given termination point.
 110      *
 111      * @param nodeId                 node ID
 112      * @param logicalConnPoint       logical connection point
 113      * @param supportingOtuInterface supporting OTU interface
 114      * @return Name of the interface if successful, otherwise return null.
 115      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
 116      */
 117
 118     public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
 119             throws OpenRoadmInterfaceException {
 120         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 121             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 122                 return openRoadmInterface121.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint,
 123                         supportingOtuInterface);
 124             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 125                 return openRoadmInterface221.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint,
 126                         supportingOtuInterface);
 127             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 128                 // Here ODUCn and ODUflex are combined
 129                 String interfaceNameOduc4 = openRoadmInterface710.createOpenRoadmOducnInterface(nodeId,
 130                     logicalConnPoint, supportingOtuInterface);
 131                 return openRoadmInterface710.createOpenRoadmOduflexInterface(nodeId, logicalConnPoint,
 132                     interfaceNameOduc4);
 133             default:
 134                 return null;
 135         }
 136     }
 137
 138     /**
 139      * This methods creates an ODU interface on the given termination point.
 140      *
 141      * @param anodeId                 node ID for A side
 142      * @param alogicalConnPoint       logical connection point for A side
 143      * @param asupportingOtuInterface supporting OTU interface
 144      * @param znodeId                 node ID for Z side
 145      * @param zlogicalConnPoint       logical connection point for Z side
 146      * @return Name of the interface if successful, otherwise return null.
 147      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
 148      */
 149
 150     public String createOpenRoadmOdu4Interface(String anodeId, String alogicalConnPoint, String asupportingOtuInterface,
 151             String znodeId, String zlogicalConnPoint)
 152             throws OpenRoadmInterfaceException {
 153         switch (mappingUtils.getOpenRoadmVersion(anodeId)) {
 154             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 155                 return openRoadmInterface121.createOpenRoadmOdu4Interface(anodeId, alogicalConnPoint,
 156                     asupportingOtuInterface);
 157             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 158                 return openRoadmInterface221.createOpenRoadmOdu4Interface(anodeId, alogicalConnPoint,
 159                     asupportingOtuInterface, znodeId, zlogicalConnPoint);
 160             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 161                 // Here ODUCn and ODUflex are combined
 162                 String interfaceNameOduc4 = openRoadmInterface710.createOpenRoadmOducnInterface(anodeId,
 163                     alogicalConnPoint, asupportingOtuInterface, znodeId, zlogicalConnPoint);
 164                 return openRoadmInterface710.createOpenRoadmOduflexInterface(anodeId, alogicalConnPoint,
 165                     interfaceNameOduc4, znodeId, zlogicalConnPoint);
 166             default:
 167                 return null;
 168         }
 169     }
 170
 171     /**
 172      * This methods creates an OTU interface on the given termination point.
 173      *
 174      * @param nodeId              node ID
 175      * @param logicalConnPoint    logical connection point
 176      * @param supportOchInterface supporting OCH interface
 177      * @return Name of the interface if successful, otherwise return null.
 178      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
 179      */
 180
 181     public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface)
 182             throws OpenRoadmInterfaceException {
 183         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 184             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 185                 return openRoadmInterface121
 186                         .createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface);
 187             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 188                 return openRoadmInterface221
 189                         .createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface);
 190             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 191                 return openRoadmInterface710.createOpenRoadmOtucnInterface(nodeId, logicalConnPoint,
 192                     supportOchInterface);
 193             default:
 194                 return null;
 195         }
 196     }
 197
 198     /**
 199      * This methods creates an OTU interface on the given termination point.
 200      *
 201      * @param anodeId node ID for A side
 202      * @param alogicalConnPoint logical connection point for A side
 203      * @param asupportOchInterface supporting OCH interface
 204      * @param znodeId node ID for the Z side
 205      * @param zlogicalConnPoint logical connection point for Z side
 206      * @return Name of the interface if successful, otherwise return null.
 207      *
 208      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
 209      */
 210
 211     public String createOpenRoadmOtu4Interface(String anodeId, String alogicalConnPoint, String asupportOchInterface,
 212             String znodeId, String zlogicalConnPoint)
 213             throws OpenRoadmInterfaceException {
 214         switch (mappingUtils.getOpenRoadmVersion(anodeId)) {
 215             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 216                 return openRoadmInterface121.createOpenRoadmOtu4Interface(anodeId,
 217                         alogicalConnPoint, asupportOchInterface);
 218             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 219                 return openRoadmInterface221.createOpenRoadmOtu4Interface(anodeId, alogicalConnPoint,
 220                         asupportOchInterface, znodeId, zlogicalConnPoint);
 221             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 222                 return openRoadmInterface710.createOpenRoadmOtucnInterface(anodeId, alogicalConnPoint,
 223                     asupportOchInterface, znodeId, zlogicalConnPoint);
 224             default:
 225                 return null;
 226         }
 227     }
 228
 229     public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, String spectralSlotNumber) {
 230         return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotNumber);
 231     }
 232
 233     public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
 234         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 235             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 236                 return openRoadmInterface121.createOpenRoadmOmsInterface(nodeId, mapping);
 237             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 238                 return openRoadmInterface221.createOpenRoadmOmsInterface(nodeId, mapping);
 239             default:
 240                 return null;
 241         }
 242     }
 243
 244     public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
 245         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 246             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 247                 return openRoadmInterface121.createOpenRoadmOtsInterface(nodeId, mapping);
 248             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 249                 return openRoadmInterface221.createOpenRoadmOtsInterface(nodeId, mapping);
 250             default:
 251                 return null;
 252         }
 253     }
 254
 255     public boolean isUsedByXc(String nodeId, String interfaceName, String xc,
 256             DeviceTransactionManager deviceTransactionManager) {
 257         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 258             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 259                 return openRoadmInterface121.isUsedByXc(nodeId, interfaceName, xc, deviceTransactionManager);
 260             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 261                 return openRoadmInterface221.isUsedByXc(nodeId, interfaceName, xc, deviceTransactionManager);
 262             default:
 263                 return false;
 264         }
 265     }
 266
 267     public boolean isUsedByOtnXc(String nodeId, String interfaceName, String xc,
 268             DeviceTransactionManager deviceTransactionManager) {
 269         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 270             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 271                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 272                 return false;
 273             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 274                 return openRoadmInterface221.isUsedByOtnXc(nodeId, interfaceName, xc, deviceTransactionManager);
 275             default:
 276                 return false;
 277         }
 278     }
 279
 280     public String createOpenRoadmEth1GInterface(String nodeId,
 281             String logicalConnPoint) throws OpenRoadmInterfaceException {
 282         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 283             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 284                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 285                 return null;
 286             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 287                 return openRoadmOtnInterface221.createOpenRoadmEth1GInterface(nodeId, logicalConnPoint);
 288             default:
 289                 return null;
 290         }
 291     }
 292
 293     public String createOpenRoadmEth10GInterface(String nodeId,
 294             String logicalConnPoint) throws OpenRoadmInterfaceException {
 295         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 296             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 297                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 298                 return null;
 299             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 300                 return openRoadmOtnInterface221.createOpenRoadmEth10GInterface(nodeId, logicalConnPoint);
 301             default:
 302                 return null;
 303         }
 304
 305     }
 306
 307     public String createOpenRoadmEth100GInterface(String nodeId,
 308             String logicalConnPoint) throws OpenRoadmInterfaceException {
 309
 310         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 311             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 312                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 313                 return null;
 314             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 315                 LOG.warn("Use Ethernet interface creation for 2.2.1, instead this method of Ether 100G");
 316                 return openRoadmInterface221.createOpenRoadmEthInterface(nodeId, logicalConnPoint);
 317             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 318                 return openRoadmOtnInterface710.createOpenRoadmEth100GInterface(nodeId, logicalConnPoint);
 319             default:
 320                 return null;
 321         }
 322
 323     }
 324
 325     public String createOpenRoadmOdu0Interface(String nodeId, String logicalConnPoint, String servicename,
 326             String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlot)
 327             throws OpenRoadmInterfaceException {
 328         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 329             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 330                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 331                 return null;
 332             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 333                 return openRoadmOtnInterface221.createOpenRoadmOdu0Interface(
 334                     nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlot);
 335             default:
 336                 return null;
 337         }
 338     }
 339
 340     public String createOpenRoadmOdu2Interface(String nodeId, String logicalConnPoint, String servicename,
 341             String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
 342             throws OpenRoadmInterfaceException {
 343         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 344             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 345                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 346                 return null;
 347             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 348                 return openRoadmOtnInterface221.createOpenRoadmOdu2Interface(
 349                     nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
 350             default:
 351                 return null;
 352         }
 353     }
 354
 355     public String createOpenRoadmOdu2eInterface(String nodeId, String logicalConnPoint, String servicename,
 356             String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
 357             throws OpenRoadmInterfaceException {
 358         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 359             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 360                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 361                 return null;
 362             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 363                 return openRoadmOtnInterface221.createOpenRoadmOdu2eInterface(
 364                         nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
 365             default:
 366                 return null;
 367         }
 368
 369     }
 370
 371     public String createOpenRoadmOtnOdu4LoInterface(String nodeId, String logicalConnPoint,
 372         String serviceName, String payLoad, boolean isNetworkPort,
 373         OpucnTribSlotDef minTribSlotNumber, OpucnTribSlotDef maxTribSlotNumber)
 374         throws OpenRoadmInterfaceException {
 375
 376         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 377             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 378                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 379                 return null;
 380             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 381                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_2_2_1_MSG);
 382                 return null;
 383             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 384                 return openRoadmOtnInterface710.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint, serviceName,
 385                     payLoad, isNetworkPort, minTribSlotNumber, maxTribSlotNumber);
 386             default:
 387                 return null;
 388         }
 389     }
 390
 391     public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
 392             throws OpenRoadmInterfaceException {
 393         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 394             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 395                 return openRoadmInterface221
 396                         .createOpenRoadmOtnOdu4Interface(nodeId, logicalConnPoint, supportingOtuInterface);
 397             default:
 398                 return null;
 399         }
 400     }
 401
 402     public String createOpenRoadmOtnOdu4Interface(String anodeId, String alogicalConnPoint,
 403             String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)
 404             throws OpenRoadmInterfaceException {
 405         switch (mappingUtils.getOpenRoadmVersion(anodeId)) {
 406             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 407                 return openRoadmInterface221
 408                     .createOpenRoadmOtnOdu4Interface(anodeId, alogicalConnPoint, asupportingOtuInterface,
 409                         znodeId, zlogicalConnPoint);
 410             default:
 411                 return null;
 412         }
 413     }
 414
 415     public String createOpenRoadmOtnOduc4Interface(String nodeId, String logicalConnPoint,
 416             String supportingOtuInterface)
 417             throws OpenRoadmInterfaceException {
 418         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 419             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 420                 return openRoadmInterface710
 421                     .createOpenRoadmOtnOducnInterface(nodeId, logicalConnPoint, supportingOtuInterface);
 422             default:
 423                 return null;
 424         }
 425     }
 426
 427     public String createOpenRoadmOtnOduc4Interface(String anodeId, String alogicalConnPoint,
 428             String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)
 429             throws OpenRoadmInterfaceException {
 430         switch (mappingUtils.getOpenRoadmVersion(anodeId)) {
 431             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 432                 return openRoadmInterface710
 433                     .createOpenRoadmOtnOducnInterface(anodeId, alogicalConnPoint, asupportingOtuInterface,
 434                         znodeId, zlogicalConnPoint);
 435             default:
 436                 return null;
 437         }
 438     }
 439 }