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