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
  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.rev200128.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 Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaceFactory.class);
  25     private final MappingUtils mappingUtils;
  26     private final OpenRoadmInterface121 openRoadmInterface121;
  27     private final OpenRoadmInterface221 openRoadmInterface221;
  28     private final OpenRoadmOtnInterface221 openRoadmOtnInterface;
  29
  30     public OpenRoadmInterfaceFactory(MappingUtils mappingUtils, OpenRoadmInterface121 openRoadmInterface121,
  31             OpenRoadmInterface221 openRoadmInterface221, OpenRoadmOtnInterface221 openRoadmOTNInterface) {
  32         this.mappingUtils = mappingUtils;
  33         this.openRoadmInterface121 = openRoadmInterface121;
  34         this.openRoadmInterface221 = openRoadmInterface221;
  35         this.openRoadmOtnInterface = openRoadmOTNInterface;
  36     }
  37
  38     public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
  39             throws OpenRoadmInterfaceException {
  40
  41         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
  42             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
  43                 return openRoadmInterface121.createOpenRoadmEthInterface(nodeId, logicalConnPoint);
  44             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
  45                 return openRoadmInterface221.createOpenRoadmEthInterface(nodeId, logicalConnPoint);
  46             default:
  47                 return null;
  48         }
  49     }
  50
  51
  52     /**
  53      * This methods creates an OCH interface on the given termination point on
  54      * Roadm.
  55      *
  56      * @param nodeId           node ID
  57      * @param logicalConnPoint logical connection point
  58      * @param waveNumber       wavelength number of the OCH interface.
  59      * @return Name of the interface if successful, otherwise return null.
  60      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
  61      */
  62
  63     public List<String> createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber)
  64             throws OpenRoadmInterfaceException {
  65
  66         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
  67             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
  68                 return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber);
  69             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
  70                 return openRoadmInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber);
  71             default:
  72                 return null;
  73         }
  74     }
  75
  76
  77     public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
  78         OchAttributes.ModulationFormat format)
  79             throws OpenRoadmInterfaceException {
  80         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
  81             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
  82                 return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber, format);
  83             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
  84                 return openRoadmInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber);
  85             default:
  86                 return null;
  87         }
  88     }
  89
  90     /**
  91      * This methods creates an ODU interface on the given termination point.
  92      *
  93      * @param nodeId                 node ID
  94      * @param logicalConnPoint       logical connection point
  95      * @param supportingOtuInterface supporting OTU interface
  96      * @return Name of the interface if successful, otherwise return null.
  97      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
  98      */
  99
 100     public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
 101             throws OpenRoadmInterfaceException {
 102         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 103             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 104                 return openRoadmInterface121.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint,
 105                         supportingOtuInterface);
 106             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 107                 return openRoadmInterface221.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint,
 108                         supportingOtuInterface);
 109             default:
 110                 return null;
 111         }
 112     }
 113
 114     /**
 115      * This methods creates an OTU interface on the given termination point.
 116      *
 117      * @param nodeId              node ID
 118      * @param logicalConnPoint    logical connection point
 119      * @param supportOchInterface supporting OCH interface
 120      * @return Name of the interface if successful, otherwise return null.
 121      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
 122      */
 123
 124     public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface)
 125             throws OpenRoadmInterfaceException {
 126         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 127             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 128                 return openRoadmInterface121
 129                         .createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface);
 130             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 131                 return openRoadmInterface221
 132                         .createOpenRoadmOtu4Interface(nodeId, logicalConnPoint, supportOchInterface);
 133             default:
 134                 return null;
 135         }
 136     }
 137
 138     public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, Long waveNumber) {
 139         return logicalConnectionPoint + "-" + waveNumber;
 140     }
 141
 142     public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
 143         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 144             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 145                 return openRoadmInterface121.createOpenRoadmOmsInterface(nodeId, mapping);
 146             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 147                 return openRoadmInterface221.createOpenRoadmOmsInterface(nodeId, mapping);
 148             default:
 149                 return null;
 150         }
 151     }
 152
 153     public String createOpenRoadmOtsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
 154         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 155             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 156                 return openRoadmInterface121.createOpenRoadmOtsInterface(nodeId, mapping);
 157             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 158                 return openRoadmInterface221.createOpenRoadmOtsInterface(nodeId, mapping);
 159             default:
 160                 return null;
 161         }
 162     }
 163
 164     public boolean isUsedbyXc(String nodeId, String interfaceName, String xc,
 165                               DeviceTransactionManager deviceTransactionManager) {
 166         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 167             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 168                 return openRoadmInterface121.isUsedByXc(nodeId, interfaceName, xc, deviceTransactionManager);
 169             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 170                 return openRoadmInterface221.isUsedByXc(nodeId, interfaceName, xc, deviceTransactionManager);
 171             default:
 172                 return false;
 173         }
 174     }
 175
 176     public boolean isUsedbyOtnXc(String nodeId, String interfaceName, String xc,
 177         DeviceTransactionManager deviceTransactionManager) {
 178         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 179             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 180                 LOG.error("OTN funtions are not supported by Openroadm models 1.2.1");
 181                 return false;
 182             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 183                 return openRoadmInterface221.isUsedByOtnXc(nodeId, interfaceName, xc, deviceTransactionManager);
 184             default:
 185                 return false;
 186         }
 187     }
 188
 189     public String createOpenRoadmEth1GInterface(String nodeId,
 190                                                 String logicalConnPoint) throws OpenRoadmInterfaceException {
 191         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 192             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 193                 LOG.error("OTN funtions are not supported by Openroadm models 1.2.1");
 194                 return null;
 195             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 196                 return openRoadmOtnInterface.createOpenRoadmEth1GInterface(nodeId, logicalConnPoint);
 197             default:
 198                 return null;
 199         }
 200     }
 201
 202     public String createOpenRoadmEth10GInterface(String nodeId,
 203                                                  String logicalConnPoint) throws OpenRoadmInterfaceException {
 204         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 205             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 206                 LOG.error("OTN funtions are not supported by Openroadm models 1.2.1");
 207                 return null;
 208             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 209                 return openRoadmOtnInterface.createOpenRoadmEth10GInterface(nodeId, logicalConnPoint);
 210             default:
 211                 return null;
 212         }
 213
 214     }
 215
 216     public String createOpenRoadmOdu0Interface(String nodeId, String logicalConnPoint, String servicename,
 217             String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlot)
 218             throws OpenRoadmInterfaceException {
 219         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 220             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 221                 LOG.error("OTN funtions are not supported by Openroadm models 1.2.1");
 222                 return null;
 223             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 224                 return openRoadmOtnInterface.createOpenRoadmOdu0Interface(
 225                     nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlot);
 226             default:
 227                 return null;
 228         }
 229     }
 230
 231     public String createOpenRoadmOdu2Interface(String nodeId, String logicalConnPoint, String servicename,
 232             String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
 233             throws OpenRoadmInterfaceException {
 234         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 235             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 236                 LOG.error("OTN funtions are not supported by Openroadm models 1.2.1");
 237                 return null;
 238             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 239                 return openRoadmOtnInterface.createOpenRoadmOdu2Interface(
 240                     nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
 241             default:
 242                 return null;
 243         }
 244     }
 245
 246     public String createOpenRoadmOdu2eInterface(String nodeId, String logicalConnPoint, String servicename,
 247             String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
 248             throws OpenRoadmInterfaceException {
 249         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 250             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 251                 LOG.error("OTN funtions are not supported by Openroadm models 1.2.1");
 252                 return null;
 253             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 254                 return openRoadmOtnInterface.createOpenRoadmOdu2eInterface(
 255                         nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
 256             default:
 257                 return null;
 258         }
 259
 260     }
 261
 262     public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
 263             throws OpenRoadmInterfaceException {
 264         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 265             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 266                 return openRoadmInterface221
 267                         .createOpenRoadmOtnOdu4Interface(nodeId, logicalConnPoint, supportingOtuInterface);
 268             default:
 269                 return null;
 270         }
 271     }
 272 }