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

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * ONAP : ccsdk features
   4  * ================================================================================
   5  * Copyright (C) 2019 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.dataprovider.data;
  23
  24 import java.util.ArrayList;
  25 import java.util.Arrays;
  26 import java.util.Date;
  27 import java.util.List;
  28
  29 import javax.annotation.Nonnull;
  30 import org.eclipse.jdt.annotation.NonNull;
  31 import org.eclipse.jdt.annotation.Nullable;
  32 import org.onap.ccsdk.features.sdnr.wt.common.database.HtDatabaseClient;
  33 import org.onap.ccsdk.features.sdnr.wt.common.database.queries.BoolQueryBuilder;
  34 import org.onap.ccsdk.features.sdnr.wt.common.database.queries.QueryBuilder;
  35 import org.onap.ccsdk.features.sdnr.wt.common.database.queries.QueryBuilders;
  36 import org.onap.ccsdk.features.sdnr.wt.common.database.queries.RangeQueryBuilder;
  37 import org.onap.ccsdk.features.sdnr.wt.dataprovider.database.EsDataObjectReaderWriter2;
  38 import org.onap.ccsdk.features.sdnr.wt.dataprovider.model.ArchiveCleanProvider;
  39 import org.onap.ccsdk.features.sdnr.wt.dataprovider.model.DataProvider;
  40 import org.onap.ccsdk.features.sdnr.wt.dataprovider.model.NetconfTimeStamp;
  41 import org.onap.ccsdk.features.sdnr.wt.dataprovider.model.types.NetconfTimeStampImpl;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DateAndTime;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.ConnectionLogStatus;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.ConnectionlogBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.ConnectionlogEntity;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.Entity;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.EventlogBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.EventlogEntity;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.FaultcurrentBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.FaultcurrentEntity;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.FaultlogBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.FaultlogEntity;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.GranularityPeriodType;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.Inventory;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.InventoryBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.InventoryEntity;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.NetworkElementConnectionBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.NetworkElementConnectionEntity;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.PmdataEntity;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.PmdataEntityBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev190801.UpdateNetworkElementConnectionInputBuilder;
  62 import org.slf4j.Logger;
  63 import org.slf4j.LoggerFactory;
  64
  65 /**
  66  * Event service, writing all events into the database into the appropriate index.
  67  *
  68  * @author herbert
  69  */
  70 public class HtDatabaseEventsService implements ArchiveCleanProvider, DataProvider {
  71     private static final Logger LOG = LoggerFactory.getLogger(HtDatabaseEventsService.class);
  72
  73     private static final NetconfTimeStamp NETCONFTIME_CONVERTER = NetconfTimeStampImpl.getConverter();
  74
  75     private HtDatabaseClient client;
  76     private EsDataObjectReaderWriter2<EventlogEntity> eventRWEventLogDevicemanager;
  77     private EsDataObjectReaderWriter2<InventoryEntity> eventRWEquipment;
  78     private EsDataObjectReaderWriter2<FaultcurrentEntity> eventRWFaultCurrentDB;
  79     private EsDataObjectReaderWriter2<FaultlogEntity> eventRWFaultLogDB;
  80     private EsDataObjectReaderWriter2<ConnectionlogEntity> eventRWConnectionLogDB;
  81     private final EsDataObjectReaderWriter2<NetworkElementConnectionEntity> networkelementConnectionDB;
  82     private final EsDataObjectReaderWriter2<PmdataEntity> pmData15mDB;
  83     private final EsDataObjectReaderWriter2<PmdataEntity> pmData24hDB;
  84
  85     @SuppressWarnings("unused")
  86     private final ElasticSearchDataProvider dataProvider;
  87     // --- Construct and initialize
  88
  89
  90     public HtDatabaseEventsService(HtDatabaseClient client, ElasticSearchDataProvider elasticSearchDataProvider)
  91             throws Exception {
  92
  93         LOG.info("Create {} start", HtDatabaseEventsService.class);
  94         this.dataProvider = elasticSearchDataProvider;
  95
  96         try {
  97             // Create control structure
  98             this.client = client;
  99
 100             eventRWEventLogDevicemanager = new EsDataObjectReaderWriter2<>(client, Entity.Eventlog,
 101                     EventlogEntity.class, EventlogBuilder.class);
 102
 103             eventRWEquipment = new EsDataObjectReaderWriter2<>(client, Entity.Inventoryequipment, InventoryEntity.class,
 104                     InventoryBuilder.class);
 105
 106             eventRWFaultCurrentDB = new EsDataObjectReaderWriter2<>(client, Entity.Faultcurrent,
 107                     FaultcurrentEntity.class, FaultcurrentBuilder.class);
 108
 109             eventRWFaultLogDB = new EsDataObjectReaderWriter2<>(client, Entity.Faultlog, FaultlogEntity.class,
 110                     FaultlogBuilder.class);
 111
 112             eventRWConnectionLogDB = new EsDataObjectReaderWriter2<>(client, Entity.Connectionlog,
 113                     ConnectionlogEntity.class, ConnectionlogBuilder.class);
 114
 115             networkelementConnectionDB = new EsDataObjectReaderWriter2<>(client, Entity.NetworkelementConnection,
 116                     NetworkElementConnectionEntity.class, NetworkElementConnectionBuilder.class)
 117                             .setEsIdAttributeName("_id");
 118
 119             pmData15mDB = new EsDataObjectReaderWriter2<>(client, Entity.Historicalperformance15min, PmdataEntity.class,
 120                     PmdataEntityBuilder.class);
 121
 122             pmData24hDB = new EsDataObjectReaderWriter2<>(client, Entity.Historicalperformance24h, PmdataEntity.class,
 123                     PmdataEntityBuilder.class);
 124
 125         } catch (Exception e) {
 126             LOG.error("Can not start database client. Exception: {}", e);
 127             throw new Exception("Can not start database client. Exception: {}", e);
 128         }
 129         LOG.info("Create {} finished. DB Service {} started.", HtDatabaseEventsService.class,
 130                 client != null ? "sucessfully" : "not");
 131     }
 132
 133     // --- Function
 134
 135     // -- Connection log
 136     @Override
 137     public void writeConnectionLog(ConnectionlogEntity event) {
 138         if (assertIfClientNull(event)) {
 139             return;
 140         }
 141         LOG.debug("Write event: {}", event);
 142         eventRWConnectionLogDB.write(event, null);
 143
 144     }
 145
 146     // -- Event log
 147     @Override
 148     public void writeEventLog(EventlogEntity event) {
 149         if (assertIfClientNull("No client to write {}", event)) {
 150             return;
 151         }
 152
 153         LOG.debug("Write event: {}", event.toString());
 154         eventRWEventLogDevicemanager.write(event, null);
 155     }
 156
 157
 158     // -- Fault log
 159
 160     @Override
 161     public void writeFaultLog(FaultlogEntity fault) {
 162         if (assertIfClientNull(fault)) {
 163             return;
 164         }
 165
 166         LOG.debug("Write fault to faultlog: {}", fault.toString());
 167         eventRWFaultLogDB.write(fault, null);
 168     }
 169
 170     // -- Fault current
 171
 172     @Override
 173     public void updateFaultCurrent(FaultcurrentEntity fault) {
 174         if (assertIfClientNull(fault)) {
 175             return;
 176         }
 177
 178         if (FaultEntityManager.isManagedAsCurrentProblem(fault)) {
 179             if (FaultEntityManager.isNoAlarmIndication(fault)) {
 180                 LOG.debug("Remove from currentFaults: {}", fault.toString());
 181                 eventRWFaultCurrentDB.remove(FaultEntityManager.genSpecificEsId(fault));
 182             } else {
 183                 LOG.debug("Write to currentFaults: {}", fault.toString());
 184                 eventRWFaultCurrentDB.write(fault, FaultEntityManager.genSpecificEsId(fault));
 185             }
 186         } else {
 187             LOG.debug("Ingnore for currentFaults: {}", fault.toString());
 188         }
 189     }
 190
 191     /**
 192      * Remove all entries for one node
 193      *
 194      * @param nodeName contains the mountpointname
 195      * @return number of deleted entries
 196      */
 197     @Override
 198     public int clearFaultsCurrentOfNode(String nodeName) {
 199         if (assertIfClientNullForNodeName(nodeName)) {
 200             return -1;
 201         }
 202
 203         LOG.debug("Remove from currentFaults all faults for node: {}", nodeName);
 204         return eventRWFaultCurrentDB.remove(EsFaultCurrent.getQueryForOneNode(nodeName));
 205     }
 206
 207     /**
 208      * Remove all entries for one node
 209      *
 210      * @param nodeName contains the mountpointname
 211      * @param objectId of element to be deleted
 212      * @return number of deleted entries
 213      */
 214     @Override
 215     public int clearFaultsCurrentOfNodeWithObjectId(String nodeName, String objectId) {
 216         if (assertIfClientNullForNodeName(nodeName)) {
 217             return -1;
 218         }
 219
 220         LOG.debug("Remove from currentFaults all faults for node/objectId: {}/{}", nodeName, objectId);
 221         return eventRWFaultCurrentDB.remove(EsFaultCurrent.getQueryForOneNodeAndObjectId(nodeName, objectId));
 222     }
 223
 224     /**
 225      * Deliver list with all mountpoint/node-names in the database.
 226      *
 227      * @return List of all mountpoint/node-names the had active alarms.
 228      */
 229     @Override
 230     public @Nonnull List<String> getAllNodesWithCurrentAlarms() {
 231         if (assertIfClientNull("No DB, can not delete for all nodes", null)) {
 232             return new ArrayList<>();
 233         }
 234
 235         LOG.debug("Remove from currentFaults faults for all node");
 236         List<String> nodeNames = new ArrayList<>();
 237
 238         for (FaultcurrentEntity fault : eventRWFaultCurrentDB.doReadAll().getHits()) {
 239             String nodeName = fault.getNodeId();
 240             if (!nodeNames.contains(nodeName)) {
 241                 // this.clearFaultsCurrentOfNode(nodeName); -> Function shifted
 242                 nodeNames.add(nodeName);
 243             }
 244         }
 245         return nodeNames;
 246     }
 247
 248     // -- Inventory and equipment current
 249
 250     /**
 251      * write internal equipment to database
 252      *
 253      * @param internalEquipment with mandatory fields.
 254      */
 255     @Override
 256     public void writeInventory(Inventory internalEquipment) {
 257
 258         if (assertIfClientNullForNodeName(internalEquipment.getNodeId())) {
 259             return;
 260         }
 261         if (internalEquipment.getManufacturerIdentifier() == null) {
 262             internalEquipment = new InventoryBuilder(internalEquipment).setManufacturerIdentifier("").build();
 263         }
 264         if (internalEquipment.getDate() == null) {
 265             internalEquipment = new InventoryBuilder(internalEquipment).setDate("").build();
 266         }
 267
 268         eventRWEquipment.write(internalEquipment, internalEquipment.getNodeId() + "/" + internalEquipment.getUuid());
 269     }
 270
 271
 272     // -- Networkelement
 273
 274     /**
 275      *
 276      * @param networkElementConnectionEntitiy to wirte to DB
 277      * @param nodeId Id for this DB element
 278      */
 279     @Override
 280     public void updateNetworkConnectionDeviceType(NetworkElementConnectionEntity networkElementConnectionEntitiy,
 281             String nodeId) {
 282         this.networkelementConnectionDB.update(networkElementConnectionEntitiy, nodeId);
 283     }
 284
 285     /**
 286      * Update after new mountpoint registration
 287      *
 288      * @param networkElementConnectionEntitiy data
 289      * @param nodeId of device (mountpoint name)
 290      */
 291     @Override
 292     public void updateNetworkConnection22(NetworkElementConnectionEntity networkElementConnectionEntitiy,
 293             String nodeId) {
 294         this.networkelementConnectionDB.updateOrCreate(networkElementConnectionEntitiy, nodeId,
 295                 Arrays.asList("is-required", "username", "password"));
 296     }
 297
 298     /* please do not remove */
 299     //    public void cleanNetworkElementConnections() {
 300     //        this.networkelementConnectionDB.remove(QueryBuilders.matchQuery("is-required", false));
 301     //        CreateNetworkElementConnectionInput x = new CreateNetworkElementConnectionInputBuilder().setStatus(ConnectionLogStatus.Disconnected).build();
 302     //        this.networkelementConnectionDB.update(x,QueryBuilders.matchAllQuery());
 303     //    }
 304
 305     @Override
 306     public void removeNetworkConnection(String nodeId) {
 307         Boolean isRequired;
 308         NetworkElementConnectionEntity e = this.networkelementConnectionDB.read(nodeId);
 309         if (e != null && (isRequired = e.isIsRequired()) != null) {
 310             if (isRequired) {
 311                 LOG.debug("updating connection status for {} of required ne to disconnected", nodeId);
 312                 this.networkelementConnectionDB.update(new UpdateNetworkElementConnectionInputBuilder()
 313                         .setStatus(ConnectionLogStatus.Disconnected).build(), nodeId);
 314             } else {
 315                 LOG.debug("remove networkelement-connection for {} entry because of non-required", nodeId);
 316                 this.networkelementConnectionDB.remove(nodeId);
 317             }
 318         } else {
 319             LOG.warn("Unable to update connection-status. dbentry for {} not found in networkelement-connection",
 320                     nodeId);
 321         }
 322     }
 323
 324     // -- Multiple areas
 325
 326     @Override
 327     public int doIndexClean(Date olderAreOutdated) {
 328
 329         String netconfTimeStamp = NETCONFTIME_CONVERTER.getTimeStampAsNetconfString(olderAreOutdated);
 330         int removed = 0;
 331
 332         QueryBuilder queryEventBase = EsEventBase.getQueryForTimeStamp(netconfTimeStamp);
 333         removed += eventRWEventLogDevicemanager.remove(queryEventBase);
 334
 335         QueryBuilder queryFaultLog = EsFaultLogDevicemanager.getQueryForTimeStamp(netconfTimeStamp);
 336         removed += eventRWFaultLogDB.remove(queryFaultLog);
 337         return removed;
 338     }
 339
 340     @Override
 341     public int getNumberOfOldObjects(Date olderAreOutdated) {
 342
 343         String netconfTimeStamp = NETCONFTIME_CONVERTER.getTimeStampAsNetconfString(olderAreOutdated);
 344         int numberOfElements = 0;
 345
 346         QueryBuilder queryEventBase = EsEventBase.getQueryForTimeStamp(netconfTimeStamp);
 347         numberOfElements += eventRWEventLogDevicemanager.doReadAll(queryEventBase).getTotal();
 348
 349         QueryBuilder queryFaultLog = EsFaultLogDevicemanager.getQueryForTimeStamp(netconfTimeStamp);
 350         numberOfElements += eventRWFaultLogDB.doReadAll(queryFaultLog).getTotal();
 351
 352         return numberOfElements;
 353     }
 354
 355     // -- Helper
 356
 357     /**
 358      * Verify status of client
 359      *
 360      * @param event that is printed with message
 361      * @return true if client is null
 362      */
 363     private boolean assertIfClientNull(Object event) {
 364         return assertIfClientNull("No DB, can not write: {}", event);
 365     }
 366
 367     private boolean assertIfClientNullForNodeName(Object object) {
 368         return assertIfClientNull("No DB, can not handle node: {}", object);
 369     }
 370
 371     /**
 372      * Verify status of client
 373      *
 374      * @param message to print including {} for object printout.
 375      * @return true if client is null
 376      */
 377     private boolean assertIfClientNull(String message, Object object) {
 378         if (client == null) {
 379             LOG.debug(message, object);
 380             return true;
 381         }
 382         return false;
 383     }
 384
 385     // ### sub classes
 386
 387
 388     private static class EsEventBase {
 389         /**
 390          * Query to get older Elements
 391          *
 392          * @param netconfTimeStamp to identify older Elements
 393          * @return QueryBuilder for older elements related to timestamp
 394          */
 395         private static QueryBuilder getQueryForTimeStamp(String netconfTimeStamp) {
 396             return new RangeQueryBuilder("timestamp").lte(netconfTimeStamp);
 397         }
 398     }
 399     private static class EsFaultLogDevicemanager {
 400         /**
 401          * Get older Elements
 402          *
 403          * @param netconfTimeStamp to identify query elements older than this timestamp.
 404          * @return QueryBuilder for related elements
 405          */
 406         public static QueryBuilder getQueryForTimeStamp(String netconfTimeStamp) {
 407             return new RangeQueryBuilder("timestamp").lte(netconfTimeStamp);
 408         }
 409     }
 410     public static class EsFaultCurrent {
 411         /**
 412          * @param nodeName name of the node
 413          * @return query builder
 414          */
 415         public static QueryBuilder getQueryForOneNode(String nodeName) {
 416             return QueryBuilders.matchQuery("node-id", nodeName);
 417         }
 418
 419         public static QueryBuilder getQueryForOneNodeAndObjectId(String nodeName, String objectId) {
 420             BoolQueryBuilder bq = QueryBuilders.boolQuery();
 421             bq.must(QueryBuilders.matchQuery("node-id", nodeName));
 422             bq.must(QueryBuilders.matchQuery("object-id", objectId));
 423             return bq;
 424         }
 425     }
 426
 427     @Override
 428     public List<NetworkElementConnectionEntity> getNetworkElementConnections() {
 429         return this.networkelementConnectionDB.doReadAll().getHits();
 430     }
 431
 432     @Override
 433     public void doWritePerformanceData(List<PmdataEntity> list) {
 434
 435         list.forEach(elem -> {
 436             GranularityPeriodType granularityPeriod = nnGetGranularityPeriodType(elem.getGranularityPeriod());
 437             //_id": "Sim12600/LP-MWPS-TTP-01/2017-07-04T15:15:00.0+00:00"
 438             StringBuffer id = new StringBuffer();
 439             DateAndTime date = elem.getTimeStamp();
 440             id.append(elem.getNodeName());
 441             id.append("/");
 442             id.append(elem.getUuidInterface());
 443             id.append("/");
 444             id.append(date != null ? date.getValue() : "null");
 445
 446             switch (granularityPeriod) {
 447                 case Period15Min:
 448                     pmData15mDB.write(elem, id.toString());
 449                     break;
 450                 case Period24Hours:
 451                     pmData24hDB.write(elem, id.toString());
 452                     break;
 453                 case Unknown:
 454                 default:
 455                     LOG.debug("Unknown granularity {} id {}", granularityPeriod, id);
 456                     break;
 457             }
 458         });
 459
 460     }
 461
 462     @NonNull
 463     GranularityPeriodType nnGetGranularityPeriodType(@Nullable GranularityPeriodType granularityPeriod) {
 464         return granularityPeriod != null ? granularityPeriod : GranularityPeriodType.Unknown;
 465     }
 466
 467     @Override
 468     public HtDatabaseClient getRawClient() {
 469         return this.client;
 470     }
 471
 472 }