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