src/o1/ves/VesCommonHeader.cpp

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2020-2021] [HCL Technologies Ltd.]                          #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains functions to support the preparation of VES common header
  20    parameters*/
  21
  22 #include <stdio.h>
  23 #include <typeinfo>
  24 #include <chrono>
  25 #include <sys/time.h>
  26 #include <ctime>
  27 #include <sstream>
  28 #include "JsonHelper.hpp"
  29 #include "VesCommonHeader.hpp"
  30 #include "VesUtils.hpp"
  31
  32 static double seqNo = 0;
  33
  34 #define MAX_TIME_STR 35
  35
  36 /*******************************************************************
  37  *
  38  * @brief provide next sequence number of VES event
  39  *
  40  * @details
  41  *
  42  *    Function : nextSequenceNo
  43  *
  44  *    Functionality:
  45  *      - provide next sequence number of VES event
  46  *
  47  * @params[in] void
  48  * @return next sequence number of event  - success
  49  *
  50  * ****************************************************************/
  51
  52 double VesCommonHeader::nextSequenceNo()
  53 {
  54    return seqNo++;
  55 }
  56
  57 /*******************************************************************
  58  *
  59  * @brief provide current sequence number of VES event
  60  *
  61  * @details
  62  *
  63  *    Function : getSequenceNo
  64  *
  65  *    Functionality:
  66  *      - provide current sequence number of VES event
  67  *
  68  * @params[in] void
  69  * @return current sequence number of event  - success
  70  *
  71  * ****************************************************************/
  72
  73 double VesCommonHeader::getSequenceNo()
  74 {
  75    return seqNo;
  76 }
  77
  78 /*******************************************************************
  79  *
  80  * @brief Convert Ves Event type to string
  81  *
  82  * @details
  83  *
  84  *    Function : getEventTypeToStr
  85  *
  86  *    Functionality:
  87  *      - Convert Ves Event type to String
  88  *
  89  * @params[in] IN - void
  90  * @return value of string     - success
  91  *         empty string        - failure
  92  *
  93  * ****************************************************************/
  94
  95 string VesCommonHeader::getEventTypeToStr()
  96 {
  97    string str = "";
  98    switch(mEventType)
  99    {
 100       case VesEventType::PNF_REGISTRATION:
 101          str = "pnfRegistration";
 102          break;
 103       case VesEventType::FAULT_NOTIFICATION:
 104          #ifdef StdDef
 105          str = "stndDefined";
 106          #else
 107          str = "fault";
 108          #endif
 109          break;
 110       case VesEventType::PM_NOTIFICATION:
 111          str = "pmNotification";
 112          break;
 113       case VesEventType::PM_SLICE:
 114          #ifdef StdDef
 115          str = "stndDefined";
 116          #else
 117          str = "measurement";
 118          #endif
 119          break;
 120       case VesEventType::HEARTBEAT:
 121          str = "heartbeat";
 122          break;
 123       default:
 124          O1_LOG("\nO1 VesCommonHeader : VES msg Type not supported");
 125          break;
 126    }
 127    return str;
 128 }
 129
 130 /*******************************************************************
 131  *
 132  * @brief create Ves Event Id from Ves Event type
 133  *
 134  * @details
 135  *
 136  *    Function : getEventId
 137  *
 138  *    Functionality:
 139  *      - create Ves Event Id from Ves Event type
 140  *
 141  * @params[in] IN - void
 142  * @return value of string     - success
 143  *         empty string        - failure
 144  *
 145  * ****************************************************************/
 146
 147 string VesCommonHeader::getEventId()
 148 {
 149   /*Currently PNF_REGISTRATION only supported. This function must be updated
 150     in later releases*/
 151    std::ostringstream oss;
 152    oss << mLastEpochTime;
 153    string stringEpochTime = oss.str().substr(0, 10);
 154    string evntId = "";
 155    switch(mEventType)
 156    {
 157       case VesEventType::PNF_REGISTRATION:
 158          evntId = getSourceName() + "_" + MODEL_NUMBER_007_DEV;
 159          break;
 160       case VesEventType::HEARTBEAT:
 161          evntId = getEventTypeToStr() + "_" + formatTime(getCurrentTime());
 162          break;
 163       case VesEventType::PM_SLICE:
 164          #ifdef StdDef
 165          evntId = SLICE_EVENTID;
 166          #else
 167          evntId = "_" + stringEpochTime + "_" + "PM1min";
 168          #endif
 169      break;
 170       case VesEventType::FAULT_NOTIFICATION:
 171          #ifdef StdDef
 172          evntId = FAULT_EVENTID;
 173          #else
 174          evntId ="O_RAN_COMPONENT_Alarms-61";
 175          #endif
 176      break;
 177       default:
 178          O1_LOG("\nO1 VesCommonHeader : this VES msg Type support in getEventId is \
 179 not available");
 180          break;
 181    }
 182    return evntId;
 183 }
 184
 185 /*******************************************************************
 186  *
 187  * @brief create Ves Event Type from Ves Event type
 188  *
 189  * @details
 190  *
 191  *    Function : getEventType
 192  *
 193  *    Functionality:
 194  *      - create Ves Event Type from Ves Event type
 195  *
 196  * @params[in] IN - void
 197  * @return value of string     - success
 198  *         empty string        - failure
 199  *
 200  * ****************************************************************/
 201
 202 string VesCommonHeader::getEventType()
 203 {
 204   /*Currently PNF_REGISTRATION only supported. This function must be updated
 205     in later releases*/
 206
 207    string evntType = "";
 208    switch(mEventType)
 209    {
 210       case VesEventType::PNF_REGISTRATION:
 211          evntType = EVENT_TYPE_5G;
 212          break;
 213       case VesEventType::HEARTBEAT:
 214          evntType = EVENT_TYPE_ORAN_COMPONENT;
 215          break;
 216       case VesEventType::PM_SLICE:
 217          #ifdef StdDef
 218          evntType = PM_SLICE_EVENT_TYPE;
 219          #else
 220          evntType = EVENT_TYPE_ORAN_COMPONENT_PM;
 221          #endif
 222          break;
 223       case VesEventType::FAULT_NOTIFICATION:
 224          evntType = FAULT_TYPE;
 225          break;
 226       default:
 227          O1_LOG("\nO1 VesCommonHeader : this VES msg Type support in getEvenType is \
 228 not available");
 229          break;
 230    }
 231    return evntType;
 232 }
 233
 234 /*******************************************************************
 235  *
 236  * @brief return priority of event
 237  *
 238  * @details
 239  *
 240  *    Function : getPriority
 241  *
 242  *    Functionality:
 243  *      - send priority of event
 244  *
 245  * @params[in] IN - void
 246  * @return value of string     - success
 247  *         empty string        - failure
 248  *
 249  * ****************************************************************/
 250
 251 string VesCommonHeader::getPriority()
 252 {
 253   /*Currently PNF_REGISTRATION only supported. This function must be updated
 254     in later releases*/
 255
 256    string evntId = "";
 257    switch(mEventType)
 258    {
 259       case VesEventType::PNF_REGISTRATION:
 260          evntId = PRIORITY_LOW ;
 261          break;
 262       case VesEventType::HEARTBEAT:
 263          evntId = PRIORITY_LOW;
 264          break;
 265       case VesEventType::PM_SLICE:
 266          evntId = PRIORITY_LOW ;
 267          break;
 268       case VesEventType::FAULT_NOTIFICATION:
 269          evntId = PRIORITY_LOW ;
 270          break;
 271       default:
 272          O1_LOG("\nO1 VesCommonHeader : This VES msg Type support in getPriority is \
 273 not available");
 274          break;
 275    }
 276    return evntId;
 277 }
 278
 279
 280
 281 /*******************************************************************
 282  *
 283  * @brief create Ves Event Name from Ves Event type
 284  *
 285  * @details
 286  *
 287  *    Function : getEventName
 288  *
 289  *    Functionality:
 290  *      - create Ves Event Name from Ves Event type
 291  *
 292  * @params[in] IN - void
 293  * @return value of string     - success
 294  *         empty string        - failure
 295  * ****************************************************************/
 296
 297 string VesCommonHeader::getEventName()
 298 {
 299   /*Currently PNF_REGISTRATION only supported. This function must be updated
 300     in later releases*/
 301
 302    string evntName = "";
 303    switch(mEventType)
 304    {
 305       case VesEventType::PNF_REGISTRATION:
 306          evntName = getEventTypeToStr() + "_" + EVENT_TYPE_5G;
 307          break;
 308       case VesEventType::HEARTBEAT:
 309          evntName = getEventTypeToStr() + "_" + EVENT_TYPE_ORAN_COMPONENT;
 310          break;
 311       case VesEventType::PM_SLICE:
 312          #ifdef StdDef
 313          evntName = PM_SLICE_EVENT_NAME;
 314          #else
 315          evntName = getEventTypeToStr() + "_" + EVENT_TYPE_ORAN_COMPONENT_PM;
 316          #endif
 317          break;
 318       case VesEventType::FAULT_NOTIFICATION:
 319          #ifdef StdDef
 320          evntName = FAULT_EVENT_NAME;
 321          #else
 322          evntName ="O_RAN_COMPONENT_Alarms";
 323          #endif
 324          break;
 325       default:
 326          O1_LOG("\nO1 VesCommonHeader : This VES msg Type support in getEventName is \
 327          not available");
 328          break;
 329    }
 330    return evntName;
 331 }
 332
 333 /*******************************************************************
 334  *
 335  * @brief create Ves Event Name from Ves Event type
 336  *
 337  * @details
 338  *
 339  *    Function : getReportingEntityId
 340  *
 341  *    Functionality:
 342  *      - create Ves Event Name from Ves Event type
 343  *
 344  * @params[in] IN - void
 345  * @return value of string     - success
 346  *         empty string        - failure
 347  * ****************************************************************/
 348
 349 string VesCommonHeader::getReportingEntityId()
 350 {
 351   /*Currently PNF_REGISTRATION and PM_SLICE are only supported.
 352    This function must be updated in later releases*/
 353
 354    string evntName = "";
 355    switch(mEventType)
 356    {
 357       case VesEventType::PNF_REGISTRATION:
 358          evntName = ODU_HIGH;
 359          break;
 360       case VesEventType::PM_SLICE:
 361          evntName = ODU_HIGH;
 362          break;
 363       case VesEventType::FAULT_NOTIFICATION:
 364          evntName = ODU_HIGH;
 365          break;
 366       default:
 367          break;
 368    }
 369    return evntName;
 370 }
 371
 372 /*******************************************************************
 373  *
 374  * @brief create Reporting Entity Name from Ves Event type
 375  *
 376  * @details
 377  *
 378  *    Function : getReportingEntityName
 379  *
 380  *    Functionality:
 381  *      - create Reporting Entity Name from Ves Event type
 382  *
 383  * @params[in] IN - void
 384  * @return value of string     - success
 385  *         empty string        - failure
 386  * ****************************************************************/
 387
 388 string VesCommonHeader::getReportingEntityName()
 389 {
 390    string evntName = "";
 391    switch(mEventType)
 392    {
 393       case VesEventType::PNF_REGISTRATION:
 394          evntName = getSourceName();
 395          break;
 396       case VesEventType::PM_SLICE:
 397          evntName = PM_REPORTING_ENTITY;
 398          break;
 399       case VesEventType::FAULT_NOTIFICATION:
 400          evntName = ODU_HIGH;
 401          break;
 402       default:
 403          O1_LOG("\nO1 VesCommonHeader : This VES msg Type support in \
 404          getReportingEntityName is not available");
 405          break;
 406    }
 407    return evntName;
 408 }
 409
 410 /*******************************************************************
 411  *
 412  * @brief create Source Name from Ves Event type
 413  *
 414  * @details
 415  *
 416  *    Function : getSourceName
 417  *
 418  *    Functionality:
 419  *      - create Source Name from Ves Event type
 420  *
 421  * @params[in] IN - void
 422  * @return value of string     - success
 423  *         empty string        - failure
 424  * ****************************************************************/
 425
 426 string VesCommonHeader::getSourceName()
 427 {
 428    string sourceName = "";
 429    switch(mEventType)
 430
 431    {
 432       case VesEventType::PNF_REGISTRATION:
 433          sourceName = ODU_HIGH;
 434          break;
 435       case VesEventType::PM_SLICE:
 436          sourceName = ODU_HIGH;
 437          break;
 438       case VesEventType::FAULT_NOTIFICATION:
 439          sourceName = ODU_HIGH;
 440          break;
 441       default:
 442          break;
 443    }
 444    return sourceName;
 445 }
 446
 447 /*******************************************************************
 448  *
 449  * @brief create Ves Event SourceId from Ves Event type
 450  *
 451  * @details
 452  *
 453  *    Function : getSourceId
 454  *
 455  *    Functionality:
 456  *      - create Ves Event SourceId from Ves Event type
 457  *
 458  * @params[in] IN - void
 459  * @return value of string     - success
 460  *         empty string        - failure
 461  * ****************************************************************/
 462 string VesCommonHeader::getSourceId()
 463 {
 464    string sourceId = "";
 465    switch(mEventType)
 466    {
 467       case VesEventType::FAULT_NOTIFICATION:
 468          sourceId = SOURCE_ID;
 469          break;
 470       default:
 471          break;
 472    }
 473    return sourceId;
 474 }
 475
 476 /*******************************************************************
 477  *
 478  * @brief create Ves Event Name from Ves Event type
 479  *
 480  * @details
 481  *
 482  *    Function : getnfcNamingCode
 483  *
 484  *    Functionality: create Ves Event nfc naming code
 485  *
 486  * @params[in] IN - void
 487  * @return value of string     - success
 488  *         empty string        - failure
 489  * ****************************************************************/
 490
 491 string VesCommonHeader::getnfcNamingCode()
 492 {
 493    string name = "";
 494    switch(mEventType)
 495    {
 496       case VesEventType::PM_SLICE:
 497          name = NFC_NAMING_CODE;
 498          break;
 499       case VesEventType::FAULT_NOTIFICATION:
 500          name = NFC_NAMING_CODE;
 501          break;
 502       default:
 503          break;
 504    }
 505    return name;
 506 }
 507
 508 /*******************************************************************
 509  *
 510  * @brief create Ves Event Name from Ves Event type
 511  *
 512  * @details
 513  *
 514  *    Function : getNamingCode
 515  *
 516  *    Functionality:
 517  *      - Network function type: 4 characters (aligned with vnf and pnf
 518            naming standards)
 519  *
 520  * @params[in] IN - void
 521  * @return value of string     - success
 522  *         empty string        - failure
 523  * ****************************************************************/
 524
 525 string VesCommonHeader::getNamingCode()
 526 {
 527
 528    string nammingcdoe = "";
 529    switch(mEventType)
 530    {
 531       case VesEventType::PNF_REGISTRATION:
 532          nammingcdoe = NAMING_CODE_ODU;
 533          break;
 534       case VesEventType::PM_SLICE:
 535          nammingcdoe = NAMING_CODE_ODU;
 536          break;
 537       case VesEventType::FAULT_NOTIFICATION:
 538          nammingcdoe = NAMING_CODE_ODU;
 539          break;
 540       default:
 541          O1_LOG("\nO1 VesCommonHeader : This VES msg Type support in \
 542          getReportingEntityName is not available");
 543          break;
 544    }
 545    return nammingcdoe;
 546 }
 547
 548
 549
 550 /*******************************************************************
 551  *
 552  * @brief provide current epoch time
 553  *
 554  * @details
 555  *
 556  *    Function : getEpochTime
 557  *
 558  *    Functionality:
 559  *      - provide current epoch time
 560  *
 561  * @params[in] void
 562  * @return epoch time     - success
 563  *
 564  * ****************************************************************/
 565
 566 double VesCommonHeader::getEpochTime()
 567 {
 568     double epochTimeInMicrosec = std::chrono::duration_cast \
 569             <std::chrono::microseconds> \
 570             (std::chrono::system_clock::now().time_since_epoch()).count();
 571     return epochTimeInMicrosec;
 572 }
 573
 574 /*******************************************************************
 575  *
 576  * @brief get current time
 577  *
 578  * @details
 579  *
 580  *    Function : getCurrentTime
 581  *
 582  *    Functionality:
 583  *      - get current time
 584  *
 585  * @params[in] void
 586  * @return time     - success
 587  *
 588  * ****************************************************************/
 589
 590 time_t VesCommonHeader::getCurrentTime()
 591 {
 592    time_t t;
 593    time(&t);
 594    return t;
 595 }
 596
 597 /*******************************************************************
 598  *
 599  * @brief formats the current time like:
 600  *           "Thu, 14 Oct 2021 03:15:00 +0000"
 601  *
 602  * @details
 603  *
 604  *    Function : formatTime
 605  *
 606  *    Functionality:
 607  *      - formats current time
 608  *
 609  * @params[in] void
 610  * @return formatted time - success
 611  *
 612  * ****************************************************************/
 613
 614 std::string VesCommonHeader::formatTime(time_t t) {
 615    std::ostringstream oss;
 616    char dateStr[MAX_TIME_STR];
 617    strftime(dateStr, sizeof(dateStr), "%a, %d %b %Y %T %z", gmtime(&t));
 618    oss << dateStr;
 619    return oss.str();
 620 }
 621
 622
 623 /*******************************************************************
 624  *
 625  * @brief create Ves stndDefinedNamespace from Ves Event type
 626  *
 627  * @details
 628  *
 629  *    Function : getstndDefinedNamespace
 630  *
 631  *    Functionality: create Ves tndDefinedNamespace
 632  *
 633  * @params[in] IN - void
 634  * @return value of string     - success
 635  *         empty string        - failure
 636  * ****************************************************************/
 637
 638 string VesCommonHeader::getstndDefinedNamespace()
 639 {
 640    string stndDefinedNamespace="";
 641    switch(mEventType)
 642    {
 643       case VesEventType::PM_SLICE:
 644          stndDefinedNamespace = PM_SLICE_STND_DEFINED_NAMESPACE;
 645          break;
 646       case VesEventType::FAULT_NOTIFICATION:
 647          stndDefinedNamespace = FAULT_STND_DEFINED_NAMESPACE;
 648          break;
 649       default:
 650          break;
 651    }
 652    return stndDefinedNamespace;
 653
 654 }
 655
 656 /*******************************************************************
 657  *
 658  * @brief Prepare VES Message
 659  *
 660  * @details
 661  *
 662  *    Function : prepare
 663  *
 664  *    Functionality:
 665  *      - prepare VES event
 666  *
 667  * @params[in] void
 668  * @return true     - success
 669  *         false    - failure
 670  *
 671  * ****************************************************************/
 672
 673
 674 bool VesCommonHeader::prepare(cJSON *commonHeader, \
 675                               VesEventType type)
 676 {
 677    bool ret=true;
 678    string typeStr;
 679    string evntId;
 680    string evntName;
 681    mEventType = type;
 682    seqNo=0;
 683    nextSequenceNo(); //update the sequence number for next message
 684    //local utility variables:
 685    time_t intervalStartTime = getCurrentTime();
 686    time_t intervalEndTime = intervalStartTime+60; /*adding 1 min to system time*/
 687    double startEpochTime = getEpochTime();
 688    mLastEpochTime = startEpochTime+60*100000; /*adding 1 min to epoch time*/
 689
 690    if(JsonHelper::addNodeToObject(commonHeader, "domain", \
 691                                   getEventTypeToStr().c_str()) == 0) {
 692       ret=false;
 693    }
 694    else if ( JsonHelper::addNodeToObject(commonHeader, "eventId", \
 695                                          getEventId().c_str()) == 0)
 696    {
 697       ret =false;
 698    }
 699    else if(JsonHelper::addNodeToObject(commonHeader, "eventName", \
 700                                        getEventName().c_str()) == 0)
 701    {
 702       ret = false;
 703    }
 704    else if(JsonHelper::addNodeToObject(commonHeader, "eventType", \
 705                                        getEventType().c_str()) == 0)
 706    {
 707       ret = false;
 708    }
 709
 710    #ifdef StdDef
 711    #else
 712    if (mEventType == VesEventType::PM_SLICE)
 713    {
 714       cJSON *internalHeaderFields = JsonHelper::createNode();
 715       if(internalHeaderFields == 0)
 716       {
 717          ret = false;
 718       }
 719       else if(JsonHelper::addJsonNodeToObject(commonHeader, "internalHeaderFields", \
 720                                           internalHeaderFields) == 0)
 721       {
 722          ret = false;
 723       }
 724       else if(JsonHelper::addNodeToObject(internalHeaderFields, "intervalEndTime", \
 725                                           formatTime(intervalEndTime).c_str()) == 0)
 726       {
 727          ret = false;
 728       }
 729       else if(JsonHelper::addNodeToObject(internalHeaderFields, "intervalStartTime", \
 730                                           formatTime(intervalStartTime).c_str()) == 0)
 731       {
 732          ret = false;
 733       }
 734    }
 735    #endif
 736
 737    if(JsonHelper::addNodeToObject(commonHeader, "sequence", \
 738                                        getSequenceNo()) == 0)
 739    {
 740       ret = false;
 741    }
 742    else if(JsonHelper::addNodeToObject(commonHeader, "priority", \
 743                                        getPriority().c_str()) == 0)
 744    {
 745       ret = false;
 746    }
 747    else if(JsonHelper::addNodeToObject(commonHeader, "reportingEntityId", \
 748                                        getReportingEntityId().c_str() ) == 0)
 749    {
 750       ret = false;
 751    }
 752    else if(JsonHelper::addNodeToObject(commonHeader, "reportingEntityName", \
 753                                        getReportingEntityName().c_str()) == 0)
 754    {
 755       ret = false;
 756    }
 757    else if(JsonHelper::addNodeToObject(commonHeader, "sourceId", \
 758                                       getSourceId().c_str() ) == 0)
 759    {
 760       ret = false;
 761    }
 762    else if(JsonHelper::addNodeToObject(commonHeader, "sourceName", \
 763                                        getSourceName().c_str()) == 0)
 764    {
 765       ret = false;
 766    }
 767    else if(JsonHelper::addNodeToObject(commonHeader, "startEpochMicrosec", \
 768                                       startEpochTime) == 0)
 769    {
 770       ret = false;
 771    }
 772    else if(JsonHelper::addNodeToObject(commonHeader, "lastEpochMicrosec", \
 773                                       mLastEpochTime) == 0)
 774    {
 775       ret = false;
 776    }
 777    else if(JsonHelper::addNodeToObject(commonHeader, "nfNamingCode", \
 778                                        getNamingCode().c_str() ) == 0)
 779    {
 780       ret = false;
 781    }
 782    else if(JsonHelper::addNodeToObject(commonHeader, "nfVendorName", \
 783                                        "POC") == 0)
 784    {
 785       ret = false;
 786    }
 787    else if(JsonHelper::addNodeToObject(commonHeader, "nfcNamingCode", \
 788                                        getnfcNamingCode().c_str() ) == 0)
 789    {
 790       ret = false;
 791    }
 792    else if(JsonHelper::addNodeToObject(commonHeader, "timeZoneOffset", \
 793                                       TIME_ZONE_00_00) == 0)
 794    {
 795       ret = false;
 796    }
 797
 798    else if(JsonHelper::addNodeToObject(commonHeader, "version", \
 799                                           COMMON_HEADER_VERSION) == 0)
 800    {
 801       ret = false;
 802    }
 803    else if(JsonHelper::addNodeToObject(commonHeader, "stndDefinedNamespace", \
 804                                        getstndDefinedNamespace().c_str())== 0)
 805    {
 806       ret = false;
 807    }
 808    else if(JsonHelper::addNodeToObject(commonHeader, "vesEventListenerVersion", \
 809                                        VES_EVENT_LISNERT_VERSION) == 0)
 810    {
 811       ret = false;
 812    }
 813    else
 814    {
 815       O1_LOG("\nO1 VesCommonHeader : VES common Header prepared");
 816    }
 817    return ret;
 818 }
 819
 820 /**********************************************************************
 821   End of file
 822  **********************************************************************/