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