gerrit.onap Code Review - ccsdk/features.git/blob

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * ONAP : ccsdk features
   4  * ================================================================================
   5  * Copyright (C) 2020 highstreet technologies GmbH Intellectual Property.
   6  * All rights reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  *
  21  */
  22 package org.onap.ccsdk.features.sdnr.wt.devicemanager.openroadm71.impl;
  23
  24 import java.util.ArrayList;
  25 import java.util.Collection;
  26 import java.util.Hashtable;
  27 import java.util.List;
  28 import org.eclipse.jdt.annotation.NonNull;
  29 import org.onap.ccsdk.features.sdnr.wt.common.YangHelper;
  30 import org.onap.ccsdk.features.sdnr.wt.dataprovider.model.NetconfTimeStamp;
  31 import org.onap.ccsdk.features.sdnr.wt.dataprovider.model.types.NetconfTimeStampImpl;
  32 import org.onap.ccsdk.features.sdnr.wt.devicemanager.service.DeviceManagerServiceProvider;
  33 import org.onap.ccsdk.features.sdnr.wt.netconfnodestateservice.NetconfAccessor;
  34 import org.onap.ccsdk.features.sdnr.wt.netconfnodestateservice.NetconfBindingAccessor;
  35 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.packs.CircuitPacks;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.Interface;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.OrgOpenroadmDevice;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.Xponder;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.shelf.Slots;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.shelves.Shelves;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.xponder.XpdrPort;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DateAndTime;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.EventlogBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.Inventory;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.PmdataEntity;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.SourceType;
  48 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  49 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  50 import org.opendaylight.yangtools.yang.binding.NotificationListener;
  51 import org.opendaylight.yangtools.yang.common.Uint32;
  52 import org.slf4j.Logger;
  53 import org.slf4j.LoggerFactory;
  54
  55 /**
  56  * @author Shabnam Sultana
  57  *
  58  *         Creating the openroadm device as an optical network element and writing inventory, fault, pm data to elastic
  59  *         search db
  60  *
  61  **/
  62 public class OpenroadmNetworkElement extends OpenroadmNetworkElementBase {
  63
  64     // variables
  65     private final long EQUIPMENTLEVEL_BASE = 0;
  66     private static final Logger LOG = LoggerFactory.getLogger(OpenroadmNetworkElement.class);
  67     private Hashtable<String, Long> circuitPacksRecord;
  68     private Hashtable<String, Long> shelfProvisionedcircuitPacks;
  69     private ListenerRegistration<NotificationListener> openRdmListenerRegistrationResult;
  70     private @NonNull final OpenroadmChangeNotificationListener openRdmListener;
  71     private ListenerRegistration<NotificationListener> opnRdmFaultListenerRegistrationResult;
  72     private @NonNull OpenroadmFaultNotificationListener opnRdmFaultListener;
  73     private ListenerRegistration<NotificationListener> opnRdmDeviceListenerRegistrationResult;
  74     private OpenroadmDeviceChangeNotificationListener opnRdmDeviceListener;
  75     private OpenroadmInventoryInput opnRdmInventoryInput;
  76     private PmDataBuilderOpenRoadm openRoadmPmData;
  77     private InitialDeviceAlarmReader initialAlarmReader;
  78
  79     private static final NetconfTimeStamp ncTimeConverter = NetconfTimeStampImpl.getConverter();
  80     private int counter = 1;
  81     // end of variables
  82
  83     // constructors
  84     public OpenroadmNetworkElement(NetconfBindingAccessor netconfAccess, DeviceManagerServiceProvider serviceProvider) {
  85
  86         super(netconfAccess, serviceProvider);
  87
  88         LOG.info("Create {}", OpenroadmNetworkElement.class.getSimpleName());
  89         this.openRdmListenerRegistrationResult = null;
  90         this.openRdmListener = new OpenroadmChangeNotificationListener(netconfAccessor, databaseService,
  91                 serviceProvider.getWebsocketService());
  92         this.opnRdmFaultListenerRegistrationResult = null;
  93         this.opnRdmFaultListener = new OpenroadmFaultNotificationListener(netconfAccessor, serviceProvider);
  94         this.opnRdmDeviceListenerRegistrationResult = null;
  95         this.opnRdmDeviceListener = new OpenroadmDeviceChangeNotificationListener(netconfAccessor, databaseService,
  96                 serviceProvider.getWebsocketService());
  97         this.circuitPacksRecord = new Hashtable<>();
  98         this.shelfProvisionedcircuitPacks = new Hashtable<>();
  99         this.openRoadmPmData = new PmDataBuilderOpenRoadm(this.netconfAccessor);
 100         this.initialAlarmReader = new InitialDeviceAlarmReader(this.netconfAccessor, serviceProvider);
 101         LOG.info("NodeId {}", this.netconfAccessor.getNodeId().getValue());
 102
 103
 104     }
 105     // end of constructors
 106
 107     // public methods
 108     public void initialReadFromNetworkElement() {
 109
 110         OrgOpenroadmDevice device = readDevice(this.netconfAccessor);
 111         this.opnRdmInventoryInput = new OpenroadmInventoryInput(this.netconfAccessor, device);
 112         LOG.info("openroadmMapper details{}", this.opnRdmInventoryInput.getClass().getName());
 113         List<Inventory> inventoryList = new ArrayList<>();
 114         inventoryList.add(this.opnRdmInventoryInput.getInventoryData(Uint32.valueOf(EQUIPMENTLEVEL_BASE)));
 115         readShelvesData(inventoryList, device);
 116         readXpndrData(inventoryList, device);
 117         readCircuitPacketData(inventoryList, device);
 118         readInterfaceData(inventoryList, device);
 119         this.databaseService.writeInventory(this.netconfAccessor.getNodeId().getValue(), inventoryList);
 120         // Writing initial alarms at the time of device registration
 121         initialAlarmReader.faultService();
 122         //        Writing historical PM data at the time of device registration
 123         List<PmdataEntity> pmDataEntity = new ArrayList<>();
 124         pmDataEntity = this.openRoadmPmData.buildPmDataEntity(this.openRoadmPmData.getPmData(this.netconfAccessor));
 125         if (!pmDataEntity.isEmpty()) {
 126             this.databaseService.doWritePerformanceData(pmDataEntity);
 127             LOG.info("PmDatEntity is written with size {}", pmDataEntity.size());
 128             for (PmdataEntity ent : pmDataEntity) {
 129                 LOG.info("GetNode: {}, granPeriod: {}", ent.getNodeName(), ent.getGranularityPeriod().getName());
 130             }
 131         } else {
 132             LOG.info("PmDatEntity is empty");
 133         }
 134     }
 135
 136
 137     @Override
 138     public void register() {
 139         initialReadFromNetworkElement();
 140
 141         this.openRdmListenerRegistrationResult = netconfAccessor.doRegisterNotificationListener(openRdmListener);
 142         this.opnRdmFaultListenerRegistrationResult =
 143                 netconfAccessor.doRegisterNotificationListener(opnRdmFaultListener);
 144         this.opnRdmDeviceListenerRegistrationResult =
 145                 netconfAccessor.doRegisterNotificationListener(opnRdmDeviceListener);
 146         if (netconfAccessor.isNotificationsRFC5277Supported()) {
 147             // Register netconf stream
 148             netconfAccessor.registerNotificationsStream(NetconfAccessor.DefaultNotificationsStream);
 149         }
 150         else {
 151             LOG.info("device {} does not support netconf notification", netconfAccessor.getNodeId().getValue());
 152         }
 153     }
 154
 155     @Override
 156     public void deregister() {
 157         if (openRdmListenerRegistrationResult != null) {
 158             this.openRdmListenerRegistrationResult.close();
 159         }
 160         if (opnRdmFaultListenerRegistrationResult != null) {
 161             this.opnRdmFaultListenerRegistrationResult.close();
 162         }
 163         if (opnRdmDeviceListenerRegistrationResult != null) {
 164             this.opnRdmDeviceListenerRegistrationResult.close();
 165         }
 166     }
 167
 168     // end of public methods
 169
 170     // private methods
 171     private void readShelvesData(List<Inventory> inventoryList, OrgOpenroadmDevice device) {
 172         Collection<Shelves> shelves = YangHelper.getCollection(device.getShelves());
 173         if (shelves != null) {
 174             for (Shelves shelf : shelves) {
 175                 LOG.info(
 176                         "Shelf Name: {}, \n Serial Id:{}, \n Product Code;{}, \n Position:{}, \n EquipmetState: {}, \n Hardware version: {}"
 177                                 + "\n ShelfType:{}, \n Vendor: {}, \n LifecycleState: {} ",
 178                         shelf.getShelfName(), shelf.getSerialId(), shelf.getProductCode(), shelf.getShelfPosition(),
 179                         shelf.getEquipmentState(), shelf.getHardwareVersion(), shelf.getShelfType(), shelf.getVendor(),
 180                         shelf.getLifecycleState());
 181                 inventoryList.add(
 182                         this.opnRdmInventoryInput.getShelvesInventory(shelf, Uint32.valueOf(EQUIPMENTLEVEL_BASE + 1)));
 183                 Collection<Slots> slotList = YangHelper.getCollection(shelf.getSlots());
 184                 if (slotList != null) {
 185                     for (Slots slot : slotList) {
 186                         if (slot.getProvisionedCircuitPack() != null) {
 187                             this.shelfProvisionedcircuitPacks.put(slot.getProvisionedCircuitPack(),
 188                                     EQUIPMENTLEVEL_BASE + 2);
 189                         }
 190                         LOG.info("Slots for the shelf: {}", shelf.getShelfName());
 191                         LOG.info("\n Slot Name: {}, \n Status: {}, \n Slot label: {} ", slot.getSlotName(),
 192                                 slot.getSlotStatus(), slot.getLabel());
 193                     }
 194                 }
 195             }
 196             LOG.info("size of shelfProvisionedcircuitPacks: {} ", shelfProvisionedcircuitPacks.size());
 197         }
 198
 199     }
 200
 201     private void readXpndrData(List<Inventory> inventoryList, OrgOpenroadmDevice device) {
 202         Collection<Xponder> xponderList = YangHelper.getCollection(device.getXponder());
 203
 204         if (xponderList != null) {
 205             for (Xponder xponder : xponderList) {
 206
 207                 inventoryList.add(this.opnRdmInventoryInput.getXponderInventory(xponder,
 208                         Uint32.valueOf(EQUIPMENTLEVEL_BASE + 1)));
 209                 LOG.info("Xponders: No.: {} , \n Port: {} ,\n Type: {}", xponder.getXpdrNumber(), xponder.getXpdrPort(),
 210                         xponder.getXpdrType());
 211                 Collection<XpdrPort> xpdrportlist = YangHelper.getCollection(xponder.getXpdrPort());
 212                 if (xpdrportlist != null) {
 213                     for (XpdrPort xpdrport : xpdrportlist)
 214                         if (xpdrport.getCircuitPackName() != null) {
 215                             this.shelfProvisionedcircuitPacks.put(xpdrport.getCircuitPackName(),
 216                                     EQUIPMENTLEVEL_BASE + 2);
 217                             LOG.info("Size of dict{}", this.shelfProvisionedcircuitPacks.size());
 218                         }
 219                 }
 220
 221             }
 222         }
 223     }
 224
 225     private void readCircuitPacketData(List<Inventory> inventoryList, OrgOpenroadmDevice device) {
 226         Collection<CircuitPacks> circuitpackCollection = YangHelper.getCollection(device.getCircuitPacks());
 227         List<String> cpNameList = new ArrayList<>();
 228
 229         if (circuitpackCollection != null) {
 230             //            collect all circuit pack names. Required to check for invalid parents later on
 231             for (CircuitPacks cp : circuitpackCollection) {
 232                 cpNameList.add(cp.getCircuitPackName());
 233             }
 234
 235             for (CircuitPacks cp : circuitpackCollection) {
 236                 LOG.info("CP Name:{}", cp.getCircuitPackName());
 237
 238                 if (cp.getParentCircuitPack() == null
 239                         && !this.shelfProvisionedcircuitPacks.containsKey(cp.getCircuitPackName())) {
 240                     LOG.info("cp has no parent and no shelf");
 241                     this.circuitPacksRecord.put(cp.getCircuitPackName(), (EQUIPMENTLEVEL_BASE + 1));
 242                     inventoryList.add(this.opnRdmInventoryInput.getCircuitPackInventory(cp,
 243                             Uint32.valueOf(EQUIPMENTLEVEL_BASE + 1)));
 244                 } else {
 245                     //                check for missing valid parent circuit name
 246                     if (cp.getParentCircuitPack().getCpSlotName() != null
 247                             && cp.getParentCircuitPack().getCircuitPackName() == null) {
 248
 249                         LOG.info("Cp {} has slotname of the parent circuit pack  but no parent circuit pack name",
 250                                 cp.getCircuitPackName());
 251                         this.circuitPacksRecord.put(cp.getCircuitPackName(), (EQUIPMENTLEVEL_BASE + 3));
 252                         inventoryList.add(this.opnRdmInventoryInput.getCircuitPackInventory(cp,
 253                                 Uint32.valueOf(EQUIPMENTLEVEL_BASE + 3)));
 254                         databaseService.writeEventLog(writeIncorrectParentLog(cp.getCircuitPackName(), counter)
 255                                 .setObjectId(device.getInfo().getNodeId().getValue())
 256                                 .setId(cp.getParentCircuitPack().getCpSlotName())
 257                                 .setNewValue("Missing parent circuit pack name").build());
 258                     } else if (cp.getParentCircuitPack().getCircuitPackName() != null
 259                             && this.shelfProvisionedcircuitPacks
 260                                     .containsKey(cp.getParentCircuitPack().getCircuitPackName())) {
 261                         LOG.info("Cp {} has parent circuit pack and shelf", cp.getCircuitPackName());
 262                         this.circuitPacksRecord.put(cp.getCircuitPackName(), (EQUIPMENTLEVEL_BASE + 3));
 263                         inventoryList.add(this.opnRdmInventoryInput.getCircuitPackInventory(cp,
 264                                 Uint32.valueOf(EQUIPMENTLEVEL_BASE + 3)));
 265                     } else {
 266                         //                      check for incorrect hierarchy
 267                         if (cp.getParentCircuitPack().getCircuitPackName() != null
 268                                 && !cpNameList.contains(cp.getParentCircuitPack().getCircuitPackName())) {
 269                             databaseService.writeEventLog(writeIncorrectParentLog(cp.getCircuitPackName(), counter)
 270                                     .setObjectId(device.getInfo().getNodeId().getValue())
 271                                     .setId(cp.getParentCircuitPack().getCpSlotName()).build());
 272                         }
 273
 274                         LOG.info("Cp has parent circuit pack but no shelf or a shelf but no parent circuit pack");
 275                         this.circuitPacksRecord.put(cp.getCircuitPackName(), (EQUIPMENTLEVEL_BASE + 2));
 276                         inventoryList.add(this.opnRdmInventoryInput.getCircuitPackInventory(cp,
 277                                 Uint32.valueOf(EQUIPMENTLEVEL_BASE + 2)));
 278                     }
 279
 280                 }
 281             }
 282
 283         }
 284     }
 285
 286     private void readInterfaceData(List<Inventory> inventoryList, OrgOpenroadmDevice device) {
 287         Collection<Interface> interfaceList = YangHelper.getCollection(device.getInterface());
 288         if (interfaceList != null) {
 289             for (Interface deviceInterface : interfaceList) {
 290                 LOG.info("\n InterfaceName: {}", deviceInterface.getName());
 291                 LOG.info("Supporting CP {}", this.circuitPacksRecord.size());
 292                 for (String s : this.circuitPacksRecord.keySet()) {
 293                     LOG.info("{} value {}", s, this.circuitPacksRecord.get(s));
 294                 }
 295                 LOG.info("Interface {} and their supporting CP {}", deviceInterface.getName(),
 296                         deviceInterface.getSupportingCircuitPackName());
 297                 if (deviceInterface.getSupportingCircuitPackName() != null) {
 298                     if (this.circuitPacksRecord.containsKey(deviceInterface.getSupportingCircuitPackName())) {
 299                         inventoryList.add(this.opnRdmInventoryInput.getInterfacesInventory(deviceInterface,
 300                                 Uint32.valueOf(
 301                                         this.circuitPacksRecord.get(deviceInterface.getSupportingCircuitPackName())
 302                                                 + 1)));
 303                     }
 304                 } else {
 305                     inventoryList.add(this.opnRdmInventoryInput.getInterfacesInventory(deviceInterface,
 306                             Uint32.valueOf(EQUIPMENTLEVEL_BASE + 1)));
 307                 }
 308             }
 309         }
 310     }
 311
 312     private OrgOpenroadmDevice readDevice(NetconfBindingAccessor accessor) {
 313         InstanceIdentifier<OrgOpenroadmDevice> deviceId = InstanceIdentifier.create(OrgOpenroadmDevice.class);
 314         return accessor.getTransactionUtils().readData(accessor.getDataBroker(), LogicalDatastoreType.OPERATIONAL,
 315                 deviceId);
 316     }
 317
 318     private EventlogBuilder writeIncorrectParentLog(String attributeName, Integer counter) {
 319         EventlogBuilder eventlogBuilder = new EventlogBuilder();
 320         eventlogBuilder.setAttributeName(attributeName).setCounter(counter)
 321                 .setNodeId(this.netconfAccessor.getNodeId().getValue()).setSourceType(SourceType.Netconf)
 322                 .setNewValue("Invalid parent circuit-pack name")
 323                 .setTimestamp(new DateAndTime(ncTimeConverter.getTimeStamp()));
 324
 325         return eventlogBuilder;
 326
 327     }
 328     // end of private methods
 329 }