common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl.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.common.openroadminterfaces;
  10
  11 import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_1_2_1;
  12 import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_2_2_1;
  13 import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_7_1;
  14
  15 import java.util.Optional;
  16 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  17 import org.opendaylight.transportpce.common.mapping.MappingUtils;
  18 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
  19 import org.slf4j.Logger;
  20 import org.slf4j.LoggerFactory;
  21
  22
  23 public class OpenRoadmInterfacesImpl implements OpenRoadmInterfaces {
  24
  25     private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfacesImpl.class);
  26
  27     OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121;
  28     OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221;
  29     OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710;
  30     MappingUtils mappingUtils;
  31
  32     public OpenRoadmInterfacesImpl(DeviceTransactionManager deviceTransactionManager, MappingUtils mappingUtils,
  33                                    OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121,
  34                                    OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221,
  35                                    OpenRoadmInterfacesImpl710 openRoadmInterfacesImpl710) {
  36         this.mappingUtils = mappingUtils;
  37         this.openRoadmInterfacesImpl121 = openRoadmInterfacesImpl121;
  38         this.openRoadmInterfacesImpl221 = openRoadmInterfacesImpl221;
  39         this.openRoadmInterfacesImpl710 = openRoadmInterfacesImpl710;
  40     }
  41
  42     @Override
  43     public <T> void postInterface(String nodeId, T ifBuilder) throws OpenRoadmInterfaceException {
  44
  45         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
  46             case OPENROADM_DEVICE_VERSION_1_2_1:
  47                 LOG.info("postInterface for 1.2.1 device {}", nodeId);
  48                 InterfaceBuilder ifBuilder121 = convertInstanceOfInterface(ifBuilder, InterfaceBuilder.class);
  49                 openRoadmInterfacesImpl121.postInterface(nodeId,ifBuilder121);
  50                 return;
  51             case OPENROADM_DEVICE_VERSION_2_2_1:
  52                 LOG.info("postInterface for 2.2.1 device {}", nodeId);
  53                 org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder
  54                     ifBuilder22 = convertInstanceOfInterface(ifBuilder, org.opendaylight.yang.gen.v1
  55                             .http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder.class);
  56                 openRoadmInterfacesImpl221.postInterface(nodeId,ifBuilder22);
  57                 return;
  58             case OPENROADM_DEVICE_VERSION_7_1:
  59                 LOG.info("postInterface for 7.1.0 device {}", nodeId);
  60                 org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder
  61                     ifBuilder71 = convertInstanceOfInterface(ifBuilder, org.opendaylight.yang.gen.v1
  62                             .http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder.class);
  63                 openRoadmInterfacesImpl710.postInterface(nodeId, ifBuilder71);
  64                 return;
  65             default:
  66                 LOG.error("postInterface unknown ordm version error device {}", nodeId);
  67                 return;
  68         }
  69     }
  70
  71     @Override
  72     @SuppressWarnings("unchecked")
  73     public <T> Optional<T>  getInterface(String nodeId, String interfaceName) throws OpenRoadmInterfaceException {
  74
  75         String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
  76         LOG.info("Interface get request received for node {} with version {}", nodeId, openRoadmVersion);
  77         switch (openRoadmVersion) {
  78             case OPENROADM_DEVICE_VERSION_1_2_1:
  79                 return (Optional<T>) openRoadmInterfacesImpl121.getInterface(nodeId,interfaceName);
  80             case OPENROADM_DEVICE_VERSION_2_2_1:
  81                 return (Optional<T>) openRoadmInterfacesImpl221.getInterface(nodeId,interfaceName);
  82             case OPENROADM_DEVICE_VERSION_7_1:
  83                 return (Optional<T>) openRoadmInterfacesImpl710.getInterface(nodeId,interfaceName);
  84             default:
  85                 LOG.error("getInterface unknown ordm version error device {}", nodeId);
  86                 return Optional.empty();
  87         }
  88     }
  89
  90     @Override
  91     public void deleteInterface(String nodeId, String interfaceName)
  92         throws OpenRoadmInterfaceException {
  93
  94         String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
  95         LOG.info("Interface delete request received for node {} with version {}", nodeId, openRoadmVersion);
  96         switch (openRoadmVersion) {
  97             case OPENROADM_DEVICE_VERSION_1_2_1:
  98                 openRoadmInterfacesImpl121.deleteInterface(nodeId,interfaceName);
  99                 return;
 100             case OPENROADM_DEVICE_VERSION_2_2_1:
 101                 openRoadmInterfacesImpl221.deleteInterface(nodeId,interfaceName);
 102                 return;
 103             case OPENROADM_DEVICE_VERSION_7_1:
 104                 openRoadmInterfacesImpl710.deleteInterface(nodeId,interfaceName);
 105                 return;
 106             default:
 107                 LOG.error("deleteInterface unknown ordm version error device {}", nodeId);
 108                 return;
 109         }
 110     }
 111
 112     @Override
 113     public void postEquipmentState(String nodeId, String circuitPackName, boolean activate)
 114         throws OpenRoadmInterfaceException {
 115
 116         String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
 117         LOG.info("Request received for node {} with version {} to change equipment-state of cp {}.",
 118             nodeId,openRoadmVersion, circuitPackName);
 119         switch (openRoadmVersion) {
 120             case OPENROADM_DEVICE_VERSION_1_2_1:
 121                 openRoadmInterfacesImpl121.postEquipmentState(nodeId, circuitPackName, activate);
 122                 return;
 123             case OPENROADM_DEVICE_VERSION_2_2_1:
 124                 openRoadmInterfacesImpl221.postEquipmentState(nodeId, circuitPackName, activate);
 125                 return;
 126             case OPENROADM_DEVICE_VERSION_7_1:
 127                 openRoadmInterfacesImpl710.postEquipmentState(nodeId, circuitPackName, activate);
 128                 return;
 129             default:
 130                 LOG.error("postEquipmentState unknown ordm version error device {}", nodeId);
 131                 return;
 132         }
 133     }
 134
 135     @Override
 136     public <T> void postOTNInterface(String nodeId, T ifBuilder)
 137         throws OpenRoadmInterfaceException {
 138
 139         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 140             case OPENROADM_DEVICE_VERSION_1_2_1:
 141                 LOG.error("postOTNInterface unsupported ordm version 1.2.1 error device {}", nodeId);
 142                 return;
 143             case OPENROADM_DEVICE_VERSION_2_2_1:
 144                 org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder
 145                     ifBuilder22 = (org.opendaylight.yang.gen.v1
 146                             .http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder) ifBuilder;
 147                 openRoadmInterfacesImpl221.postInterface(nodeId, ifBuilder22);
 148                 return;
 149             case OPENROADM_DEVICE_VERSION_7_1:
 150                 org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder
 151                     ifBuilder71 = (org.opendaylight.yang.gen.v1
 152                             .http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder) ifBuilder;
 153                 openRoadmInterfacesImpl710.postInterface(nodeId, ifBuilder71);
 154                 return;
 155             default:
 156                 LOG.error("postOTNInterface unknown ordm version error device {}", nodeId);
 157                 return;
 158         }
 159     }
 160
 161     @Override
 162     public void postOTNEquipmentState(String nodeId, String circuitPackName, boolean activate)
 163         throws OpenRoadmInterfaceException {
 164
 165         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 166             case OPENROADM_DEVICE_VERSION_1_2_1:
 167                 LOG.error("postOTNEquipmentState unsupported ordm version 1.2.1 error device {}", nodeId);
 168                 return;
 169             case OPENROADM_DEVICE_VERSION_2_2_1:
 170                 openRoadmInterfacesImpl221.postEquipmentState(nodeId, circuitPackName, activate);
 171                 return;
 172             case OPENROADM_DEVICE_VERSION_7_1:
 173                 openRoadmInterfacesImpl710.postEquipmentState(nodeId, circuitPackName, activate);
 174                 return;
 175             default:
 176                 LOG.error("postOTNEquipmentState unknown ordm version error device {}", nodeId);
 177                 return;
 178         }
 179     }
 180
 181     private <T> T convertInstanceOfInterface(Object object, Class<T> classToCast) {
 182         try {
 183             return classToCast.cast(object);
 184         } catch (ClassCastException e) {
 185             return null;
 186         }
 187     }
 188
 189     @Override
 190     public String getSupportedInterface(String nodeId, String interfaceName) {
 191         String supportedInterface = "";
 192         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
 193             case OPENROADM_DEVICE_VERSION_1_2_1:
 194                 supportedInterface = openRoadmInterfacesImpl121.getSupportedInterface(nodeId,interfaceName);
 195                 break;
 196             case OPENROADM_DEVICE_VERSION_2_2_1:
 197                 supportedInterface = openRoadmInterfacesImpl221.getSupportedInterface(nodeId,interfaceName);
 198                 break;
 199             case OPENROADM_DEVICE_VERSION_7_1:
 200                 supportedInterface = openRoadmInterfacesImpl710.getSupportedInterface(nodeId,interfaceName);
 201                 break;
 202             default:
 203                 LOG.error("getSupportedInterface unknown ordm version error device {}", nodeId);
 204         }
 205         return supportedInterface;
 206     }
 207
 208 }