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.math.BigDecimal;
  12 import java.util.List;
  13 import org.opendaylight.transportpce.common.StringConstants;
  14 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  15 import org.opendaylight.transportpce.common.fixedflex.GridConstant;
  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.rev201012.network.nodes.Mapping;
  19 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.OchAttributes;
  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 funtions are not supported by Openroadm models 1.2.1";
  27     private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaceFactory.class);
  28     private final MappingUtils mappingUtils;
  29     private final OpenRoadmInterface121 openRoadmInterface121;
  30     private final OpenRoadmInterface221 openRoadmInterface221;
  31     private final OpenRoadmOtnInterface221 openRoadmOtnInterface;
  32
  33     public OpenRoadmInterfaceFactory(MappingUtils mappingUtils, OpenRoadmInterface121 openRoadmInterface121,
  34             OpenRoadmInterface221 openRoadmInterface221, OpenRoadmOtnInterface221 openRoadmOTNInterface) {
  35         this.mappingUtils = mappingUtils;
  36         this.openRoadmInterface121 = openRoadmInterface121;
  37         this.openRoadmInterface221 = openRoadmInterface221;
  38         this.openRoadmOtnInterface = openRoadmOTNInterface;
  39     }
  40
  41     public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
  42             throws OpenRoadmInterfaceException {
  43
  44         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
  45             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
  46                 return openRoadmInterface121.createOpenRoadmEthInterface(nodeId, logicalConnPoint);
  47             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
  48                 return openRoadmInterface221.createOpenRoadmEthInterface(nodeId, logicalConnPoint);
  49             default:
  50                 return null;
  51         }
  52     }
  53
  54     public List<String> createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
  55             BigDecimal centerFreq, BigDecimal width, int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
  56             throws OpenRoadmInterfaceException {
  57         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
  58             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
  59                 return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber,
  60                         lowerSpectralSlotNumber, higherSpectralSlotNumber);
  61             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
  62                 return openRoadmInterface221.createFlexOCH(nodeId, logicalConnPoint, centerFreq,
  63                         width, lowerSpectralSlotNumber, higherSpectralSlotNumber);
  64             default:
  65                 return null;
  66         }
  67     }
  68
  69     /**
  70      * This methods creates an OCH interface on the given termination point on
  71      * Roadm.
  72      *
  73      * @param nodeId           node ID
  74      * @param logicalConnPoint logical connection point
  75      * @param waveNumber       wavelength number of the OCH interface.
  76      * @param lowerSpectralSlotNumber int
  77      * @param higherSpectralSlotNumber int
  78      * @return Name of the interface if successful, otherwise return null.
  79      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
  80      */
  81     public List<String> createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
  82             int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
  83             throws OpenRoadmInterfaceException {
  84         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
  85             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
  86                 return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber,
  87                         lowerSpectralSlotNumber, higherSpectralSlotNumber);
  88             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
  89                 return openRoadmInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber,
  90                         lowerSpectralSlotNumber, higherSpectralSlotNumber);
  91             default:
  92                 return null;
  93         }
  94     }
  95
  96     public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
  97             OchAttributes.ModulationFormat format, BigDecimal centerFreq, int lowerSpectralSlotNumber,
  98             int higherSpectralSlotNumber)
  99             throws OpenRoadmInterfaceException {
 100         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 101             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 102                 return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber, format,
 103                         lowerSpectralSlotNumber, higherSpectralSlotNumber);
 104             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 105                 return openRoadmInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, centerFreq,
 106                    lowerSpectralSlotNumber, higherSpectralSlotNumber, format.getName());
 107             default:
 108                 return null;
 109         }
 110     }
 111
 112     public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
 113             OchAttributes.ModulationFormat format, int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
 114             throws OpenRoadmInterfaceException {
 115         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 116             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 117                 return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber, format,
 118                         lowerSpectralSlotNumber, higherSpectralSlotNumber);
 119             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 120                 return openRoadmInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber,
 121                         lowerSpectralSlotNumber, higherSpectralSlotNumber);
 122             default:
 123                 return null;
 124         }
 125     }
 126
 127     /**
 128      * This methods creates an ODU interface on the given termination point.
 129      *
 130      * @param nodeId                 node ID
 131      * @param logicalConnPoint       logical connection point
 132      * @param supportingOtuInterface supporting OTU interface
 133      * @return Name of the interface if successful, otherwise return null.
 134      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
 135      */
 136
 137     public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
 138             throws OpenRoadmInterfaceException {
 139         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 140             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 141                 return openRoadmInterface121.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint,
 142                         supportingOtuInterface);
 143             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 144                 return openRoadmInterface221.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint,
 145                         supportingOtuInterface);
 146             default:
 147                 return null;
 148         }
 149     }
 150
 151     /**
 152      * This methods creates an ODU interface on the given termination point.
 153      *
 154      * @param anodeId                 node ID for A side
 155      * @param alogicalConnPoint       logical connection point for A side
 156      * @param asupportingOtuInterface supporting OTU interface
 157      * @param znodeId                 node ID for Z side
 158      * @param zlogicalConnPoint       logical connection point for Z side
 159      * @return Name of the interface if successful, otherwise return null.
 160      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
 161      */
 162
 163     public String createOpenRoadmOdu4Interface(String anodeId, String alogicalConnPoint, String asupportingOtuInterface,
 164             String znodeId, String zlogicalConnPoint)
 165             throws OpenRoadmInterfaceException {
 166         switch (mappingUtils.getOpenRoadmVersion(anodeId)) {
 167             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 168                 return openRoadmInterface121.createOpenRoadmOdu4Interface(anodeId, alogicalConnPoint,
 169                     asupportingOtuInterface);
 170             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 171                 return openRoadmInterface221.createOpenRoadmOdu4Interface(anodeId, alogicalConnPoint,
 172                     asupportingOtuInterface, znodeId, zlogicalConnPoint);
 173             default:
 174                 return null;
 175         }
 176     }
 177
 178     /**
 179      * This methods creates an OTU interface on the given termination point.
 180      *
 181      * @param nodeId              node ID
 182      * @param logicalConnPoint    logical connection point
 183      * @param supportOchInterface supporting OCH interface
 184      * @return Name of the interface if successful, otherwise return null.
 185      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
 186      */
 187
 188     public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface)
 189             throws OpenRoadmInterfaceException {
 190         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 191             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 192                 return openRoadmInterface121
 193                         .createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface);
 194             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 195                 return openRoadmInterface221
 196                         .createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface);
 197             default:
 198                 return null;
 199         }
 200     }
 201
 202     /**
 203      * This methods creates an OTU interface on the given termination point.
 204      *
 205      * @param anodeId node ID for A side
 206      * @param alogicalConnPoint logical connection point for A side
 207      * @param asupportOchInterface supporting OCH interface
 208      * @param znodeId node ID for the Z side
 209      * @param zlogicalConnPoint logical connection point for Z side
 210      * @return Name of the interface if successful, otherwise return null.
 211      *
 212      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
 213      */
 214
 215     public String createOpenRoadmOtu4Interface(String anodeId, String alogicalConnPoint, String asupportOchInterface,
 216             String znodeId, String zlogicalConnPoint)
 217             throws OpenRoadmInterfaceException {
 218         switch (mappingUtils.getOpenRoadmVersion(anodeId)) {
 219             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 220                 return openRoadmInterface121.createOpenRoadmOtu4Interface(anodeId,
 221                         alogicalConnPoint, asupportOchInterface);
 222             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 223                 return openRoadmInterface221.createOpenRoadmOtu4Interface(anodeId, alogicalConnPoint,
 224                         asupportOchInterface, znodeId, zlogicalConnPoint);
 225             default:
 226                 return null;
 227         }
 228     }
 229
 230     public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, String spectralSlotNumber) {
 231         return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotNumber);
 232     }
 233
 234     public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
 235         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 236             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 237                 return openRoadmInterface121.createOpenRoadmOmsInterface(nodeId, mapping);
 238             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 239                 return openRoadmInterface221.createOpenRoadmOmsInterface(nodeId, mapping);
 240             default:
 241                 return null;
 242         }
 243     }
 244
 245     public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
 246         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 247             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 248                 return openRoadmInterface121.createOpenRoadmOtsInterface(nodeId, mapping);
 249             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 250                 return openRoadmInterface221.createOpenRoadmOtsInterface(nodeId, mapping);
 251             default:
 252                 return null;
 253         }
 254     }
 255
 256     public boolean isUsedByXc(String nodeId, String interfaceName, String xc,
 257                               DeviceTransactionManager deviceTransactionManager) {
 258         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 259             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 260                 return openRoadmInterface121.isUsedByXc(nodeId, interfaceName, xc, deviceTransactionManager);
 261             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 262                 return openRoadmInterface221.isUsedByXc(nodeId, interfaceName, xc, deviceTransactionManager);
 263             default:
 264                 return false;
 265         }
 266     }
 267
 268     public boolean isUsedByOtnXc(String nodeId, String interfaceName, String xc,
 269             DeviceTransactionManager deviceTransactionManager) {
 270         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 271             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 272                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 273                 return false;
 274             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 275                 return openRoadmInterface221.isUsedByOtnXc(nodeId, interfaceName, xc, deviceTransactionManager);
 276             default:
 277                 return false;
 278         }
 279     }
 280
 281     public String createOpenRoadmEth1GInterface(String nodeId,
 282                                                 String logicalConnPoint) throws OpenRoadmInterfaceException {
 283         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 284             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 285                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 286                 return null;
 287             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 288                 return openRoadmOtnInterface.createOpenRoadmEth1GInterface(nodeId, logicalConnPoint);
 289             default:
 290                 return null;
 291         }
 292     }
 293
 294     public String createOpenRoadmEth10GInterface(String nodeId,
 295                                                  String logicalConnPoint) throws OpenRoadmInterfaceException {
 296         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 297             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 298                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 299                 return null;
 300             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 301                 return openRoadmOtnInterface.createOpenRoadmEth10GInterface(nodeId, logicalConnPoint);
 302             default:
 303                 return null;
 304         }
 305
 306     }
 307
 308     public String createOpenRoadmOdu0Interface(String nodeId, String logicalConnPoint, String servicename,
 309             String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlot)
 310             throws OpenRoadmInterfaceException {
 311         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 312             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 313                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 314                 return null;
 315             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 316                 return openRoadmOtnInterface.createOpenRoadmOdu0Interface(
 317                     nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlot);
 318             default:
 319                 return null;
 320         }
 321     }
 322
 323     public String createOpenRoadmOdu2Interface(String nodeId, String logicalConnPoint, String servicename,
 324             String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
 325             throws OpenRoadmInterfaceException {
 326         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 327             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 328                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 329                 return null;
 330             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 331                 return openRoadmOtnInterface.createOpenRoadmOdu2Interface(
 332                     nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
 333             default:
 334                 return null;
 335         }
 336     }
 337
 338     public String createOpenRoadmOdu2eInterface(String nodeId, String logicalConnPoint, String servicename,
 339             String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
 340             throws OpenRoadmInterfaceException {
 341         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 342             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 343                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
 344                 return null;
 345             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 346                 return openRoadmOtnInterface.createOpenRoadmOdu2eInterface(
 347                         nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
 348             default:
 349                 return null;
 350         }
 351
 352     }
 353
 354     public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
 355             throws OpenRoadmInterfaceException {
 356         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 357             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 358                 return openRoadmInterface221
 359                         .createOpenRoadmOtnOdu4Interface(nodeId, logicalConnPoint, supportingOtuInterface);
 360             default:
 361                 return null;
 362         }
 363     }
 364
 365     public String createOpenRoadmOtnOdu4Interface(String anodeId, String alogicalConnPoint,
 366             String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)
 367             throws OpenRoadmInterfaceException {
 368         switch (mappingUtils.getOpenRoadmVersion(anodeId)) {
 369             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 370                 return openRoadmInterface221
 371                     .createOpenRoadmOtnOdu4Interface(anodeId, alogicalConnPoint, asupportingOtuInterface,
 372                         znodeId, zlogicalConnPoint);
 373             default:
 374                 return null;
 375         }
 376     }
 377 }