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