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