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