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.rev210927.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 ODU interface on the given termination point.
 173      *
 174      * @param nodeId                 node ID
 175      * @param logicalConnPoint       logical connection point
 176      * @param isNetworkPort          to distinguish a CTP from a TTP
 177      * @param supportingInterface supporting OTU4 or 100GE interface
 178      * @return Name of the interface if successful, otherwise return null.
 179      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
 180      */
 181
 182     public String createOpenRoadmOdu4HOInterface(String nodeId, String logicalConnPoint, boolean isNetworkPort,
 183             String supportingInterface) throws OpenRoadmInterfaceException {
 184         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 185             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 186                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 187                 return null;
 188             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 189                 return openRoadmInterface221.createOpenRoadmOdu4HOInterface(nodeId, logicalConnPoint, isNetworkPort,
 190                     supportingInterface);
 191             default:
 192                 return null;
 193         }
 194     }
 195
 196     /**
 197      * This methods creates an OTU interface on the given termination point.
 198      *
 199      * @param nodeId              node ID
 200      * @param logicalConnPoint    logical connection point
 201      * @param supportOchInterface supporting OCH interface
 202      * @return Name of the interface if successful, otherwise return null.
 203      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
 204      */
 205
 206     public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface)
 207             throws OpenRoadmInterfaceException {
 208         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 209             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 210                 return openRoadmInterface121
 211                         .createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface);
 212             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 213                 return openRoadmInterface221
 214                         .createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface);
 215             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 216                 return openRoadmInterface710.createOpenRoadmOtucnInterface(nodeId, logicalConnPoint,
 217                     supportOchInterface);
 218             default:
 219                 return null;
 220         }
 221     }
 222
 223     /**
 224      * This methods creates an OTU interface on the given termination point.
 225      *
 226      * @param anodeId node ID for A side
 227      * @param alogicalConnPoint logical connection point for A side
 228      * @param asupportOchInterface supporting OCH interface
 229      * @param znodeId node ID for the Z side
 230      * @param zlogicalConnPoint logical connection point for Z side
 231      * @return Name of the interface if successful, otherwise return null.
 232      *
 233      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
 234      */
 235
 236     public String createOpenRoadmOtu4Interface(String anodeId, String alogicalConnPoint, String asupportOchInterface,
 237             String znodeId, String zlogicalConnPoint)
 238             throws OpenRoadmInterfaceException {
 239         switch (mappingUtils.getOpenRoadmVersion(anodeId)) {
 240             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 241                 return openRoadmInterface121.createOpenRoadmOtu4Interface(anodeId,
 242                         alogicalConnPoint, asupportOchInterface);
 243             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 244                 return openRoadmInterface221.createOpenRoadmOtu4Interface(anodeId, alogicalConnPoint,
 245                         asupportOchInterface, znodeId, zlogicalConnPoint);
 246             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 247                 return openRoadmInterface710.createOpenRoadmOtucnInterface(anodeId, alogicalConnPoint,
 248                     asupportOchInterface, znodeId, zlogicalConnPoint);
 249             default:
 250                 return null;
 251         }
 252     }
 253
 254     public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, String spectralSlotNumber) {
 255         return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotNumber);
 256     }
 257
 258     public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
 259         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 260             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 261                 return openRoadmInterface121.createOpenRoadmOmsInterface(nodeId, mapping);
 262             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 263                 return openRoadmInterface221.createOpenRoadmOmsInterface(nodeId, mapping);
 264             default:
 265                 return null;
 266         }
 267     }
 268
 269     public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
 270         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 271             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 272                 return openRoadmInterface121.createOpenRoadmOtsInterface(nodeId, mapping);
 273             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 274                 return openRoadmInterface221.createOpenRoadmOtsInterface(nodeId, mapping);
 275             default:
 276                 return null;
 277         }
 278     }
 279
 280     public boolean isUsedByXc(String nodeId, String interfaceName, String xc,
 281             DeviceTransactionManager deviceTransactionManager) {
 282         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 283             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 284                 return openRoadmInterface121.isUsedByXc(nodeId, interfaceName, xc, deviceTransactionManager);
 285             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 286                 return openRoadmInterface221.isUsedByXc(nodeId, interfaceName, xc, deviceTransactionManager);
 287             default:
 288                 return false;
 289         }
 290     }
 291
 292     public boolean isUsedByOtnXc(String nodeId, String interfaceName, String xc,
 293             DeviceTransactionManager deviceTransactionManager) {
 294         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 295             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 296                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 297                 return false;
 298             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 299                 return openRoadmInterface221.isUsedByOtnXc(nodeId, interfaceName, xc, deviceTransactionManager);
 300             default:
 301                 return false;
 302         }
 303     }
 304
 305     public String createOpenRoadmEth1GInterface(String nodeId,
 306             String logicalConnPoint) throws OpenRoadmInterfaceException {
 307         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 308             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 309                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 310                 return null;
 311             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 312                 return openRoadmOtnInterface221.createOpenRoadmEth1GInterface(nodeId, logicalConnPoint);
 313             default:
 314                 return null;
 315         }
 316     }
 317
 318     public String createOpenRoadmEth10GInterface(String nodeId,
 319             String logicalConnPoint) throws OpenRoadmInterfaceException {
 320         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 321             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 322                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 323                 return null;
 324             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 325                 return openRoadmOtnInterface221.createOpenRoadmEth10GInterface(nodeId, logicalConnPoint);
 326             default:
 327                 return null;
 328         }
 329
 330     }
 331
 332     public String createOpenRoadmEth100GInterface(String nodeId,
 333             String logicalConnPoint) throws OpenRoadmInterfaceException {
 334
 335         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 336             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 337                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 338                 return null;
 339             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 340                 LOG.warn("Use Ethernet interface creation for 2.2.1, instead this method of Ether 100G");
 341                 return openRoadmInterface221.createOpenRoadmEthInterface(nodeId, logicalConnPoint);
 342             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 343                 return openRoadmOtnInterface710.createOpenRoadmEth100GInterface(nodeId, logicalConnPoint);
 344             default:
 345                 return null;
 346         }
 347
 348     }
 349
 350     public String createOpenRoadmOdu0Interface(String nodeId, String logicalConnPoint, String servicename,
 351             String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlot)
 352             throws OpenRoadmInterfaceException {
 353         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 354             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 355                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 356                 return null;
 357             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 358                 return openRoadmOtnInterface221.createOpenRoadmOdu0Interface(
 359                     nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlot);
 360             default:
 361                 return null;
 362         }
 363     }
 364
 365     public String createOpenRoadmOdu2Interface(String nodeId, String logicalConnPoint, String servicename,
 366             String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
 367             throws OpenRoadmInterfaceException {
 368         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 369             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 370                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 371                 return null;
 372             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 373                 return openRoadmOtnInterface221.createOpenRoadmOdu2Interface(
 374                     nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
 375             default:
 376                 return null;
 377         }
 378     }
 379
 380     public String createOpenRoadmOdu2eInterface(String nodeId, String logicalConnPoint, String servicename,
 381             String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
 382             throws OpenRoadmInterfaceException {
 383         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 384             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 385                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 386                 return null;
 387             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 388                 return openRoadmOtnInterface221.createOpenRoadmOdu2eInterface(
 389                         nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
 390             default:
 391                 return null;
 392         }
 393
 394     }
 395
 396     public String createOpenRoadmOtnOdu4LoInterface(String nodeId, String logicalConnPoint,
 397         String serviceName, String payLoad, boolean isNetworkPort,
 398         OpucnTribSlotDef minTribSlotNumber, OpucnTribSlotDef maxTribSlotNumber)
 399         throws OpenRoadmInterfaceException {
 400
 401         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 402             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 403                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 404                 return null;
 405             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 406                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_2_2_1_MSG);
 407                 return null;
 408             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 409                 return openRoadmOtnInterface710.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint, serviceName,
 410                     payLoad, isNetworkPort, minTribSlotNumber, maxTribSlotNumber);
 411             default:
 412                 return null;
 413         }
 414     }
 415
 416     public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
 417             throws OpenRoadmInterfaceException {
 418         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 419             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 420                 return openRoadmInterface221
 421                         .createOpenRoadmOtnOdu4Interface(nodeId, logicalConnPoint, supportingOtuInterface);
 422             default:
 423                 return null;
 424         }
 425     }
 426
 427     public String createOpenRoadmOtnOdu4Interface(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_2_2_1:
 432                 return openRoadmInterface221
 433                     .createOpenRoadmOtnOdu4Interface(anodeId, alogicalConnPoint, asupportingOtuInterface,
 434                         znodeId, zlogicalConnPoint);
 435             default:
 436                 return null;
 437         }
 438     }
 439
 440     public String createOpenRoadmOtnOduc4Interface(String nodeId, String logicalConnPoint,
 441             String supportingOtuInterface)
 442             throws OpenRoadmInterfaceException {
 443         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 444             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 445                 return openRoadmInterface710
 446                     .createOpenRoadmOtnOducnInterface(nodeId, logicalConnPoint, supportingOtuInterface);
 447             default:
 448                 return null;
 449         }
 450     }
 451
 452     public String createOpenRoadmOtnOduc4Interface(String anodeId, String alogicalConnPoint,
 453             String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)
 454             throws OpenRoadmInterfaceException {
 455         switch (mappingUtils.getOpenRoadmVersion(anodeId)) {
 456             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
 457                 return openRoadmInterface710
 458                     .createOpenRoadmOtnOducnInterface(anodeId, alogicalConnPoint, asupportingOtuInterface,
 459                         znodeId, zlogicalConnPoint);
 460             default:
 461                 return null;
 462         }
 463     }
 464 }