From 17cf21bcf8a2e29d2cbcf0a313474d2a4ee44f5d Mon Sep 17 00:00:00 2001 From: Tadao Tanikawa Date: Fri, 20 Nov 2020 23:36:23 +0900 Subject: Re-organized sub-directory by category Since all the sub-directories were placed in the first level, created sub-directories, "hal", "module", and "service" for classification and relocated each component. Signed-off-by: Tadao Tanikawa Change-Id: Ifdf743ac0d1893bd8e445455cf0d2c199a011d5c --- .../server/src/app_states.cpp | 2684 ++++++++++++++++++++ .../notificationpersistentservice_application.cpp | 258 ++ .../src/notificationpersistentservice_main.cpp | 131 + .../server/src/ns_npp.cpp | 1149 +++++++++ .../server/src/ns_npp_archive.cpp | 846 ++++++ .../server/src/ns_npp_binary_accesser.cpp | 649 +++++ .../server/src/ns_npp_copy_worker.cpp | 1153 +++++++++ .../server/src/ns_npp_fs_directory.cpp | 232 ++ .../server/src/ns_npp_handlelist.cpp | 149 ++ .../src/ns_npp_nor_persistence_worker_thread.cpp | 747 ++++++ .../server/src/ns_npp_notification.cpp | 485 ++++ .../server/src/ns_npp_notification_manager.cpp | 1558 ++++++++++++ .../server/src/ns_npp_notification_receiver.cpp | 50 + .../server/src/ns_npp_persist_file.cpp | 100 + .../server/src/ns_npp_persist_folder.cpp | 96 + .../server/src/ns_npp_persistence.cpp | 743 ++++++ .../server/src/ns_npp_persistence_manager.cpp | 1132 +++++++++ .../server/src/ns_npp_persistent_data.cpp | 58 + .../server/src/ns_npp_personalization_manager.cpp | 181 ++ .../server/src/ns_npp_registry_entry.cpp | 333 +++ .../server/src/ns_npp_regular_notification.cpp | 158 ++ .../ns_npp_state_nor_persistence_notification.cpp | 305 +++ .../server/src/ns_npp_state_notification.cpp | 402 +++ .../src/ns_npp_state_persistence_notification.cpp | 87 + .../ns_npp_state_persistence_user_notification.cpp | 61 + 25 files changed, 13747 insertions(+) create mode 100755 service/native/notification_persistent_service/server/src/app_states.cpp create mode 100755 service/native/notification_persistent_service/server/src/notificationpersistentservice_application.cpp create mode 100755 service/native/notification_persistent_service/server/src/notificationpersistentservice_main.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_archive.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_binary_accesser.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_copy_worker.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_fs_directory.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_handlelist.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_nor_persistence_worker_thread.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_notification.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_notification_manager.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_notification_receiver.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_persist_file.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_persist_folder.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_persistence.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_persistence_manager.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_persistent_data.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_personalization_manager.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_registry_entry.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_regular_notification.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_state_nor_persistence_notification.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_state_notification.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_state_persistence_notification.cpp create mode 100755 service/native/notification_persistent_service/server/src/ns_npp_state_persistence_user_notification.cpp (limited to 'service/native/notification_persistent_service/server/src') diff --git a/service/native/notification_persistent_service/server/src/app_states.cpp b/service/native/notification_persistent_service/server/src/app_states.cpp new file mode 100755 index 0000000..c54508b --- /dev/null +++ b/service/native/notification_persistent_service/server/src/app_states.cpp @@ -0,0 +1,2684 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of internal transitions of state machine +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include +#include +#include "app_states.h" +#include "ns_npp.h" +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_notification_manager.h" +#include "ns_npp_persistence_manager.h" +#include "ns_npp_persistent_data.h" +#include "ns_npp_personalization_manager.h" + + +#ifdef NPP_PROFILEINFO_ENABLE +#include +#endif + +#ifdef AGL_STUB +#include +#endif + +static size_t NppUIToA(unsigned int value, char *buf) { + static const char c[] = "0123456789"; + char b[12]; + char *p = b + sizeof(b); + int i = 0; + + *--p = '\0'; + do { + *--p = c[value % 10]; + value /= 10; + ++i; + } while (value); + strcpy(buf, p); // NOLINT (runtime/printf) + + return i; +} + +static size_t NppStrlcpy(char *dst, const char *src, size_t siz) { + size_t ret = strlen(src); + + if (siz) { // LCOV_EXCL_BR_LINE 6: siz can't be 0 + size_t len = (ret >= siz) ? siz - 1 : ret; + memcpy(dst, src, len); + dst[len] = '\0'; + } + return ret; +} + +#define NPP_SET_FIXSTR(buf, str) \ + do { \ + strcpy(buf, str); /* NOLINT (runtime/printf) */ \ + buf += sizeof(str) - 1; \ + } while (0) + +#define NPP_SET_VARSTR(buf, str, siz) \ + buf += NppStrlcpy(buf, str, siz) + +extern CHAR g_csendreadyackto[]; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPRegisterNotifications +/// The state machine executes this transition when event for registering notification is triggered. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPRegisterNotifications) { // NOLINT (readability/naming) + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + CHKNULL(f_pSourceState); + NC_register_multiple_notif_msg *l_pMsg = NULL; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + // get app name of message source + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + + if (NULL != l_pNotificationManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager can't be NULL + UI_32 l_uiMsgLength = FrameworkunifiedGetMsgLength(l_pHApp); + + if (l_uiMsgLength <= 0) { // LCOV_EXCL_BR_LINE 6: l_uiMsgLength must be greater than 0 + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't register notifications. Invalid message length received."); // LCOV_EXCL_LINE 6: l_uiMsgLength must be greater than 0 // NOLINT[whitespace/line_length] + } else { + std::vector l_vData = std::vector(l_uiMsgLength); + + // get the received data + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize( + l_pHApp, &l_vData[0], static_cast(l_vData.size()), eSMRRelease))) { + l_pMsg = reinterpret_cast(&l_vData[0]); + + if (NULL != l_pMsg) { // LCOV_EXCL_BR_LINE 6: l_pMsg can't be NULL + NC_register_notif_msg *l_pEventInfo = NULL; + + // register all the notifications + for (UI_32 l_uiCount = 0; + l_uiCount < l_pMsg->numNotifications; + ++l_uiCount) { + l_pEventInfo = &l_pMsg->notifierList[l_uiCount]; + + if (NULL != l_pEventInfo) { // LCOV_EXCL_BR_LINE 6: l_pEventInfo can't be NULL + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Register Notfn request, src=%s, name=%s, len=%d, type=%d", + l_cMsgSource, l_pEventInfo->notificationName, l_pEventInfo->maxLength, l_pEventInfo->persType); + + // register the notification + if (eFrameworkunifiedStatusOK != l_pNotificationManager->NotificationpersistentserviceServiceOnRegisterEvents(l_cMsgSource, + l_pEventInfo->notificationName, + l_pEventInfo->maxLength, + l_pEventInfo->persType)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error in NotificationpersistentserviceServiceOnRegisterEvents :: %s", l_pEventInfo->notificationName); + } + } else { + // LCOV_EXCL_START 6: l_pEventInfo can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't register notification from source %s. l_pEventInfo is NULL", l_cMsgSource); + // LCOV_EXCL_STOP + } + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid src mq"); // LCOV_EXCL_LINE 6: l_pMsg can't be NULL + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't register notifications from source %s, Unable to get message data. Error Status: 0x%x", + l_cMsgSource, l_estatus); + } + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pNotificationManager is NULL"); // LCOV_EXCL_LINE 6: l_pNotificationManager can't be NULL // NOLINT[whitespace/line_length] + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPSubscribeToNotification +/// The state machine executes this transition when event for subscribing single notification is +/// triggered. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPSubscribeToNotification) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + CHKNULL(f_pSourceState); + NC_subscribe_msg l_objSubscribeMsg; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + + if (NULL != l_pNotificationManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager can't be NULL + if (FrameworkunifiedGetMsgLength(l_pHApp) == sizeof(NC_subscribe_msg)) { // LCOV_EXCL_BR_LINE 4: NSFW error case + // get the data received + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, static_cast(&l_objSubscribeMsg), sizeof(NC_subscribe_msg), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] +#ifdef NPP_PERFORMANCE_ANALYZE_ENABLE + char buf[128]; + char *p = buf; + NPP_SET_FIXSTR(p, "Subscribing Notfn request, src="); + NPP_SET_VARSTR(p, l_cMsgSource, sizeof(buf) - (p - buf)); + NPP_SET_FIXSTR(p, ", name="); + strcpy(p, l_objSubscribeMsg.notificationName); // NOLINT (runtime/printf) + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, buf); + /* FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, + * "Subscribing Notfn request, src=%s, name=%s", + * l_cMsgSource, l_objSubscribeMsg.notificationName);*/ +#endif // ifdef NPP_PERFORMANCE_ANALYZE_ENABLE + + // subscribe for notification + if (eFrameworkunifiedStatusOK != l_pNotificationManager->NotificationpersistentserviceServiceOnSubscribeToEvent( + l_cMsgSource, + l_objSubscribeMsg.notificationName)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error in NotificationpersistentserviceServiceOnSubscribeToEvent :: %s", l_objSubscribeMsg.notificationName); + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't subscribe to notification from source %s. Unable to get msg data, status: 0x%x", + l_cMsgSource, l_estatus); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't subscribe to notification from source %s. Invalid message length received.", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: l_pNotificationManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't subscribe to notification from source %s. l_pNotificationManager is NULL", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPSubscribeToNotifications +/// The state machine executes this transition when event for subscribing multiple notification is +/// triggered. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPSubscribeToNotifications) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + CHKNULL(f_pSourceState); + NC_subscribe_multiple_notif_msg *l_pMsg = NULL; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + + if (NULL != l_pNotificationManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager can't be NULL + UI_32 l_uiMsgLength = FrameworkunifiedGetMsgLength(l_pHApp); + + if (l_uiMsgLength <= 0) { // LCOV_EXCL_BR_LINE 6: l_uiMsgLength must be greater than 0 + // LCOV_EXCL_START 6: l_uiMsgLength must be greater than 0 + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid msg len"); + // LCOV_EXCL_STOP + } else { + std::vector l_vData = std::vector(l_uiMsgLength); + + // get the data received + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &l_vData[0], static_cast(l_vData.size()), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + l_pMsg = reinterpret_cast(&l_vData[0]); + + if (NULL != l_pMsg) { // LCOV_EXCL_BR_LINE 6: l_pMsg can't be NULL + NC_subscribe_msg *l_pEventInfo = NULL; + + // subscribe to multiple notifications + for (UI_32 l_uiCount = 0; + l_uiCount < l_pMsg->numNotifications; + ++l_uiCount) { + l_pEventInfo = &l_pMsg->notificationList[l_uiCount]; + + if (NULL != l_pEventInfo) { // LCOV_EXCL_BR_LINE 6: l_pEventInfo can't be NULL +#ifdef NPP_PERFORMANCE_ANALYZE_ENABLE + char buf[128]; + char *p = buf; + NPP_SET_FIXSTR(p, "Subscribe Notfn request, src="); + NPP_SET_VARSTR(p, l_cMsgSource, sizeof(buf) - (p - buf)); + NPP_SET_FIXSTR(p, ", name="); + strcpy(p, l_pEventInfo->notificationName); // NOLINT (runtime/printf) + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, buf); + /* FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, + "Subscribe Notfn request, src=%s, name=%s", + l_cMsgSource, + l_pEventInfo->notificationName);*/ +#endif // ifdef NPP_PERFORMANCE_ANALYZE_ENABLE + + // subscribe to notification + if (eFrameworkunifiedStatusOK != l_pNotificationManager->NotificationpersistentserviceServiceOnSubscribeToEvent( + l_cMsgSource, + l_pEventInfo->notificationName)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error in NotificationpersistentserviceServiceOnSubscribeToEvent :: %s", l_pEventInfo->notificationName); + } + } else { + // LCOV_EXCL_START 6: l_pEventInfo can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Unable to subscribe to notifications from source %s, l_pEventInfo is NULL", l_cMsgSource); + // LCOV_EXCL_STOP + } + } + } else { + // LCOV_EXCL_START 6: l_pMsg can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Unable to subscribe to notifications from source %s, Invalid src mq", l_cMsgSource); + // LCOV_EXCL_STOP + } + + l_vData.clear(); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Unable to subscribe to notifications from source %s, error retrieving message data, status: 0x%x", + l_cMsgSource, + l_estatus); + // LCOV_EXCL_STOP + } + } + } else { + // LCOV_EXCL_START 6: l_pNotificationManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Unable to subscribe to notifications from source %s, l_pNotificationManager is NULL", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPPublishNotification +/// The state machine executes this transition when event for publishing notification is triggered. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPPublishNotification) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + CHKNULL(f_pSourceState); + + CHAR l_cData[MAX_SYS_INFO_SIZE]; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + // get the app name of message source + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + + if (NULL != l_pNotificationManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager can't be NULL + // retrieve notification name + FrameworkunifiedGetSystemInfo(l_pHApp, l_cData); + + UI_32 l_uiMsgLength = FrameworkunifiedGetMsgLength(l_pHApp); + + char buf[144]; + char *p = buf; + NPP_SET_FIXSTR(p, "Publish Notfn request, src="); + NPP_SET_VARSTR(p, l_cMsgSource, sizeof(buf) - (p - buf)); + NPP_SET_FIXSTR(p, ", name="); + NPP_SET_VARSTR(p, l_cData, sizeof(buf) - (p - buf)); + NPP_SET_FIXSTR(p, ", len="); + NppUIToA(l_uiMsgLength, p); + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, buf); + /* FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, + "Publish Notfn request, src=%s, name=%s, len=%d", + l_cMsgSource, l_cData, l_uiMsgLength);*/ + + if (0 != l_uiMsgLength) { + std::vector pMsgData = std::vector(l_uiMsgLength); + + // get the received data + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &pMsgData[0], static_cast(pMsgData.size()), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + // publish the notification + (VOID)l_pNotificationManager->NotificationpersistentserviceServiceOnPublishEvent(l_cMsgSource, l_cData, + (PVOID)&pMsgData[0], l_uiMsgLength); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't publish notification from source %s, Unable to get messsage data, Error Status: 0x%x", + l_cMsgSource, l_estatus); + // LCOV_EXCL_STOP 4: NSFW error case + } + } else { + // publish the notification + (VOID)l_pNotificationManager->NotificationpersistentserviceServiceOnPublishEvent(l_cMsgSource, l_cData, NULL, l_uiMsgLength); + } + } else { + // LCOV_EXCL_START 6: l_pNotificationManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't publish notification from source %s. l_pNotificationManager is NULL", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPUnSubscribeFromNotification +/// The state machine executes this transition when event for unsubscribing notification is triggered. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPUnSubscribeFromNotification) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + CHKNULL(f_pSourceState); + NC_unsubscribe_frm_notif_msg unsubscribeMsg; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + // get the msg source name + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + + if (NULL != l_pNotificationManager) { // LCOV_EXCL_BR_LINE 200: l_pNotificationManager can't be NULL + if (FrameworkunifiedGetMsgLength(l_pHApp) == sizeof(NC_unsubscribe_frm_notif_msg)) { // LCOV_EXCL_BR_LINE 4: NSFW error case + // get the received data + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, static_cast(&unsubscribeMsg), sizeof(NC_unsubscribe_frm_notif_msg), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Source: %s is unsubscribing from notification: %s", l_cMsgSource, + unsubscribeMsg.notificationName); + + // unsubscribe from notification + if (eFrameworkunifiedStatusOK != l_pNotificationManager->NotificationpersistentserviceServiceOnUnSubscribeFromEvent( + l_cMsgSource, + unsubscribeMsg.notificationName)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error in NotificationpersistentserviceServiceOnUnSubscribeFromEvent :: %s", + unsubscribeMsg.notificationName); + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "%s is unable to subscribe from notification, error getting message data, status: 0x%x", + l_cMsgSource, l_estatus); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't unsubscribe to notification from source %s, Invalid Message size received.", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: l_pNotificationManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't unsubscribe to notification from source %s, l_pNotificationManager is NULL", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPUnSubscribeFromNotification +/// The state machine executes this transition when event for unsubscribing notification is triggered. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPUnSubscribeFromNotifications) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + CHKNULL(f_pSourceState); + NC_unsubscribe_multiple_notif_msg *l_pMsg = NULL; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + + if (NULL != l_pNotificationManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager can't be NULL + UI_32 l_uiMsgLength = FrameworkunifiedGetMsgLength(l_pHApp); + + if (l_uiMsgLength <= 0) { // LCOV_EXCL_BR_LINE 6: l_uiMsgLength must be greater than 0 + // LCOV_EXCL_START 6: l_uiMsgLength must be greater than 0 + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't unsubscribe from notifications from source %s. Invalid message length received", + l_cMsgSource); + // LCOV_EXCL_STOP + } else { + std::vector l_vData = std::vector(l_uiMsgLength); + + // get the data received + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &l_vData[0], static_cast(l_vData.size()), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + l_pMsg = reinterpret_cast(&l_vData[0]); + + if (NULL != l_pMsg) { // LCOV_EXCL_BR_LINE 6: l_pMsg can't be NULL + NC_unsubscribe_frm_notif_msg *l_pEventInfo = NULL; + + // subscribe to multiple notifications + for (UI_32 l_uiCount = 0; + l_uiCount < l_pMsg->numNotifications; + ++l_uiCount) { + l_pEventInfo = &l_pMsg->notificationList[l_uiCount]; + + if (NULL != l_pEventInfo) { // LCOV_EXCL_BR_LINE 6: l_pEventInfo can't be NULL + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Source: %s is unsubscribing from notification: %s", l_cMsgSource, + l_pEventInfo->notificationName); + + // unsubscribe from notification + if (eFrameworkunifiedStatusOK != l_pNotificationManager->NotificationpersistentserviceServiceOnUnSubscribeFromEvent( + l_cMsgSource, + l_pEventInfo->notificationName)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error in NotificationpersistentserviceServiceOnUnSubscribeFromEvent :: %s", l_pEventInfo->notificationName); + } + + } else { + // LCOV_EXCL_START 6: l_pEventInfo can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't unsubscribe from notifications from source %s. l_pEventInfo is NULL", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } + } else { + // LCOV_EXCL_START 6: l_pMsg can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't unsubscribe from notifications from source %s. Invalid src mq", l_cMsgSource); + // LCOV_EXCL_STOP + } + + l_vData.clear(); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't unsubscribe from notifications from source %s, error getting message data, status: 0x%x", + l_cMsgSource, + l_estatus); + // LCOV_EXCL_STOP + } + } + } else { + // LCOV_EXCL_START 6: l_pNotificationManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't unsubscribe from notifications from source %s. l_pNotificationManager is NULL", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPUnRegisterNotifications +/// The state machine executes this transition when event for unregistering notifications is triggered. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPUnRegisterNotifications) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + CHKNULL(f_pSourceState); + NC_unregister_multiple_notif_msg *l_pMsg = NULL; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + // get the source name + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + + if (NULL != l_pNotificationManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager can't be NULL + UI_32 l_uiMsgLength = FrameworkunifiedGetMsgLength(l_pHApp); + + if (l_uiMsgLength <= 0) { // LCOV_EXCL_BR_LINE 6: l_uiMsgLength must be greater than 0 + // LCOV_EXCL_START 6: l_uiMsgLength must be greater than 0 + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't unregister to notifications from source %s. Invalid message length received.", + l_cMsgSource); + // LCOV_EXCL_STOP + } else { + std::vectorl_vData = std::vector(l_uiMsgLength); + + // get the received data + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &l_vData[0], static_cast(l_vData.size()), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + l_pMsg = reinterpret_cast(&l_vData[0]); + + // unregister multiple notifications + if (NULL != l_cMsgSource && NULL != l_pMsg) { // LCOV_EXCL_BR_LINE 6: l_cMsgSource and l_pMsg can't be NULL + NC_unregister_notif_msg *l_pEventInfo = NULL; + + for (UI_32 l_uiCount = 0; + l_uiCount < l_pMsg->numNotifications; + ++l_uiCount) { + l_pEventInfo = &l_pMsg->notificationList[l_uiCount]; + + if (NULL != l_pEventInfo) { // LCOV_EXCL_BR_LINE 6: l_pEventInfo can't be NULL + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Source %s is unregistering to notification %s", l_cMsgSource, + l_pEventInfo->notificationName); + + // unregister notification + if (eFrameworkunifiedStatusOK != l_pNotificationManager->NotificationpersistentserviceServiceOnUnRegisterEvents( + l_cMsgSource, + l_pEventInfo->notificationName)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error in NotificationpersistentserviceServiceOnUnRegisterEvents :: %s", l_pEventInfo->notificationName); + } + } else { + // LCOV_EXCL_START 6: l_pEventInfo can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't unregister to notifications from source %s, l_pEventInfo is NULL", l_cMsgSource); + // LCOV_EXCL_STOP + } + } + } else { + // LCOV_EXCL_START 6: l_cMsgSource and l_pMsg can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't unregister to notificationsfrom source %s, Invalid src mq ", l_cMsgSource); + // LCOV_EXCL_STOP + } + + l_vData.clear(); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't unregister to notifications from source %s, Unable to get message data, status: 0x%x", + l_cMsgSource, l_estatus); + } + } + } else { + // LCOV_EXCL_START 6: l_pNotificationManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't unregister to notifications from source %s, l_pNotificationManager is NULL", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPReadPersistedData +/// The state machine executes this transition when event for getting notification's persistent data +/// is triggered. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPReadPersistedData) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + CHKNULL(f_pSourceState); + NC_get_pers_data_msg l_tMsg; + + l_tMsg.notificationName[0] = '\0'; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + // get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + + if (NULL != l_pNotificationManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager can't be NULL + if (FrameworkunifiedGetMsgLength(l_pHApp) == sizeof(NC_get_pers_data_msg)) { // LCOV_EXCL_BR_LINE 4: NSFW error case + // get the message data received + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, static_cast(&l_tMsg), sizeof(NC_get_pers_data_msg), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Source %s is requesting to read data for persistent notification %s", + l_cMsgSource, l_tMsg.notificationName); + // get persistent data related to notification + if (eFrameworkunifiedStatusOK != (l_estatus = l_pNotificationManager->NotificationpersistentserviceServiceOnGetPersistentData( + l_tMsg.notificationName, + l_cMsgSource))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in NotificationpersistentserviceServiceOnGetPersistentData :: %s", l_tMsg.notificationName); + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't read persistent data for source %s, Error getting message data, status: 0x%x", + l_cMsgSource, l_estatus); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't read persistent data for source %s. Invalid Message size received.", + l_cMsgSource); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: l_pNotificationManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't read persistent data for source %s. l_pNotificationManager is NULL", + l_cMsgSource); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + + // if any error occurs while reading persistent data, send failed ack to the requestor + if (eFrameworkunifiedStatusOK != l_estatus) { + HANDLE l_hReceiverMq = McOpenSender(l_cMsgSource); + if (NULL != l_hReceiverMq) { // LCOV_EXCL_BR_LINE 4: NSFW error case. + NC_get_persdata_failed_ack gpdFailed = {}; + std::strncpy(&gpdFailed.notificationName[0], l_tMsg.notificationName, MAX_STRING_SIZE_NOTIFICATION); + + // send the failure ack to requester + l_estatus = McSend(l_hReceiverMq, AppName, NPS_GET_PERS_DATA_FAILED_ACK, sizeof(gpdFailed), &gpdFailed); // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, + "Sent NPS_GET_PERS_DATA_FAILED_ACK to %s. Status: %d.", + l_cMsgSource, l_estatus); + + McClose(l_hReceiverMq); + } else { + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in opening sender queue of %s. Can't send NPS_GET_PERS_DATA_FAILED_ACK", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPPublishImmediateNotification +/// This transition is executed when service updates the immediate notification data +/// using synchronous API +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPPublishImmediateNotification) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + CHKNULL(f_pSourceState); + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + // get the app name of message source + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CHKNULL(l_pNotificationpersistentserviceHSM); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + // get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + CHKNULL(l_pNotificationManager); + + CHAR l_cNotfName[MAX_SYS_INFO_SIZE] = {}; + + // retrieve notification name + (VOID)FrameworkunifiedGetSystemInfo(l_pHApp, l_cNotfName); + + UI_32 l_uiMsgLength = FrameworkunifiedGetMsgLength(l_pHApp); + + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, + "Warning::Notification %s published using sync API by %s, Data length: %d", + l_cNotfName, + l_cMsgSource, l_uiMsgLength); + + if (0 != l_uiMsgLength) { + std::vector pMsgData = std::vector(l_uiMsgLength); + + // get the received data + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &pMsgData[0], l_uiMsgLength, eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + // publish the notification + (VOID)l_pNotificationManager->NotificationpersistentservicePublishImmediateNotification(l_cMsgSource, l_cNotfName, (PVOID)&pMsgData[0], + l_uiMsgLength); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't publish notification %s from source %s, Unable to get messsage data, Error Status: 0x%x", + l_cNotfName, + l_cMsgSource, l_estatus); + // LCOV_EXCL_STOP + } + } else { + // publish the notification + (VOID)l_pNotificationManager->NotificationpersistentservicePublishImmediateNotification(l_cMsgSource, l_cNotfName, NULL, l_uiMsgLength); + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + f_pSourceState = NULL; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPPersistentSync +/// Processing which synchronizes by NPPService (syncfs) +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPPersistentSync) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + CHKNULL(f_pSourceState); + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CHKNULL(l_pNotificationpersistentserviceHSM); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + CHKNULL(l_pnsnpp); + + if (TRUE == l_pnsnpp->Syncfs()) { // LCOV_EXCL_BR_LINE 6: always return true + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "syncfs are processed."); // LCOV_EXCL_LINE 6: always return true + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPReleaseFileAck) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + + NSP_CopyStatusResponse l_tCpStatus = {}; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CHKNULL(l_pNotificationpersistentserviceHSM); + + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + if (eFrameworkunifiedStatusOK == FrameworkunifiedGetMsgDataOfSize(l_pHApp, (PVOID)&l_tCpStatus, sizeof(l_tCpStatus), eSMRRelease)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "%s for tag: %s sender: %s, persist type:%d", + (l_tCpStatus.m_bpersistencechk ? "Successful copy" : "Non-Successful copy"), + l_tCpStatus.m_cpersistenttag, l_tCpStatus.m_crequesterappname, l_tCpStatus.m_eloadtype); + + if (LOADTYPE_LOAD == l_tCpStatus.m_eloadtype) { // ack for load file/folder + HANDLE hMq = NULL; + NC_LoadPersistedAck l_tMsgAck = {}; + + // HANDLE hMq = McOpenSender(l_tCpStatus.sender); + hMq = FrameworkunifiedMcOpenSender(l_pHApp, l_tCpStatus.m_crequesterappname); + + // send NC_LoadPersistedAck to the requester + l_tMsgAck.eStatus = (TRUE == l_tCpStatus.m_bpersistencechk) ? eFrameworkunifiedStatusOK : eFrameworkunifiedStatusFail; + +#ifdef AGL_PosixBasedOS001LEGACY_USED + strlcpy(l_tMsgAck.cTag, l_tCpStatus.m_cpersistenttag, sizeof(l_tMsgAck.cTag)); +#endif + + if (NULL == hMq) { // LCOV_EXCL_BR_LINE 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + // catastrophic failure! + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "McOpenSender failed for %s ", l_tCpStatus.m_crequesterappname); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } else { + if (ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE == l_tCpStatus.m_epersisttype) { + // send ack to requester for file successfully persisted + if (eFrameworkunifiedStatusOK != FrameworkunifiedSendMsg(hMq, NPS_GET_PERS_FILE_ACK, sizeof(l_tMsgAck), &l_tMsgAck)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "ERROR :: Sending NPS_GET_PERS_FILE_ACK message to %s", l_tCpStatus.m_crequesterappname); + // LCOV_EXCL_STOP + } else { + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, + "NPS_GET_PERS_FILE_ACK is sent to %s for file tag %s and load status: %d.", + l_tCpStatus.m_crequesterappname, l_tMsgAck.cTag, l_tMsgAck.eStatus); + } + } else if (ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER == l_tCpStatus.m_epersisttype) { // LCOV_EXCL_BR_LINE 6: m_epersisttype must be ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE or ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER // NOLINT[whitespace/line_length] + // send ack to requester for folder successfully persisted + if (eFrameworkunifiedStatusOK != FrameworkunifiedSendMsg(hMq, NPS_GET_PERS_FOLDER_ACK, sizeof(l_tMsgAck), &l_tMsgAck)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "ERROR :: Sending NPS_GET_PERS_FOLDER_ACK message to %s", l_tCpStatus.m_crequesterappname); + // LCOV_EXCL_STOP + } else { + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, + "NPS_GET_PERS_FOLDER_ACK is sent to %s for folder tag %s and load status: %d.", + l_tCpStatus.m_crequesterappname, l_tMsgAck.cTag, l_tMsgAck.eStatus); + } + } else { + // do nothing + } + // close mq + FrameworkunifiedMcClose(hMq); + hMq = NULL; + } + } + + // Update registry + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + if (l_pPersistenceManager) { // LCOV_EXCL_BR_LINE 6: unexpected branch can't be NULL + l_pPersistenceManager->AckReceivedFromWorker(l_tCpStatus.m_crequesterappname, + l_tCpStatus.m_cpersistenttag, + l_tCpStatus.m_epersisttype, + l_tCpStatus.m_bpersistencechk, + l_tCpStatus.m_eloadtype); + } + + if (LOADTYPE_RELEASE == l_tCpStatus.m_eloadtype) { + f_pSourceState->FrameworkunifiedPostEvent(EVENT(evCheckAllFilesPersisted)); + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "ERROR ::invalid length FrameworkunifiedGetMsgDataOfSize expected(%ld)", static_cast(sizeof(l_tCpStatus))); // NOLINT (runtime/int) + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + + +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnSaveDataAck) { // LCOV_EXCL_START 6: unused code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnUserChange +/// The state machine executes this transition when event to set or change personality is received +/// from the system. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnUserChange) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + try { + CHKNULL(f_pSourceState); + NC_User l_tMsg; + std::string l_cCurrentUsername; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + // TODO(my_username): Only accept user change from authorized app. Compare l_cMsgSource with authorized source. + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, static_cast(&l_tMsg), sizeof(NC_User), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + if (NULL != l_pnsnpp) { // LCOV_EXCL_BR_LINE 6: l_pnsnpp can't be NULL + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + CnotificationpersistentservicePersonalizationManager *l_pPersonalizationManager = l_pnsnpp->m_pPersonalizationManager; + + if (NULL != l_pPersonalizationManager) { // LCOV_EXCL_BR_LINE 6: l_pPersonalizationManager can't be NULL + l_pPersonalizationManager->NotificationpersistentserviceGetPersonality(l_cCurrentUsername); + } + + // writes the temporary user files and folders to permanent memory + if (NULL != l_pPersistenceManager) { // LCOV_EXCL_BR_LINE 6: l_pPersistenceManager can't be NULL + if (!l_cCurrentUsername.empty()) { // LCOV_EXCL_BR_LINE 6: double check, l_cCurrentUsername can't be empty + if (eFrameworkunifiedStatusOK != l_pPersistenceManager->NotificationpersistentservicePersistAllUserRequests()) { // LCOV_EXCL_BR_LINE 6: NotificationpersistentservicePersistAllUserRequests will always return ok // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error while persisting user files and folders."); // LCOV_EXCL_LINE 6: NotificationpersistentservicePersistAllUserRequests will always return ok // NOLINT[whitespace/line_length] + } + } + } + + // save the user persistent notification data + if (eFrameworkunifiedStatusOK != l_pnsnpp->NotificationpersistentserviceSaveNotificationPersistentData(eFrameworkunifiedPersistedStateUserVar)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error while NotificationpersistentserviceSaveNotificationPersistentData"); + } + } + + // set new personality + SetPersonality(l_pHApp, l_tMsg); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, + "Cannot set new personality, error getting message data, status: 0x%x", l_estatus); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +// ===========Shutdown +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnShutdownTimeout) { // LCOV_EXCL_START 200: cannot test code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} +// LCOV_EXCL_STOP + +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceCheckAllReleaseRequestsProcessed) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + CHKNULL(f_pSourceState); + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CHKNULL(l_pNotificationpersistentserviceHSM); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + CHKNULL(l_pPersistenceManager); + if (TRUE == l_pPersistenceManager->HaveAllReleaseRequestsPersisted()) { // LCOV_EXCL_BR_LINE 6: always return ok + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "All release requests are processed."); + f_pSourceState->FrameworkunifiedPostEvent(EVENT(evIdle)); + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceReInitShutdownTimer) { // LCOV_EXCL_START 8: not be used + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} +// LCOV_EXCL_STOP + +CsNotificationpersistentserviceNPPStart::CsNotificationpersistentserviceNPPStart(std::string f_strName): CFrameworkunifiedOrthogonalState(f_strName) { +} + +CsNotificationpersistentserviceNPPStart::~CsNotificationpersistentserviceNPPStart() { // LCOV_EXCL_START 200: cannot test code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert +} +// LCOV_EXCL_STOP + +EFrameworkunifiedStatus CsNotificationpersistentserviceNPPStart::FrameworkunifiedOnEntry(CEventDataPtr f_peventdata) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + + try { + HANDLE l_pHApp = FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + // Get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + + if (l_pNotificationManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager can't be NULL + NC_User l_tMsg = {}; + + // register the user change notification + if (eFrameworkunifiedStatusOK != l_pNotificationManager->NotificationpersistentserviceServiceOnRegisterEvents(AppName, // LCOV_EXCL_BR_LINE 6: always return ok // NOLINT[whitespace/line_length] + NTFY_NPPService_UserChange, + sizeof(NC_User), + eFrameworkunifiedPersistedStateVar)) { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in user change notification registration."); // LCOV_EXCL_LINE 6: always return ok // NOLINT[whitespace/line_length] + } + + // Set initial user. By default, NS_NPPService will set the current user as last user. If no + // last user found set the default user. + UI_32 l_uiUserNotificationDataSize = 0; + EFrameworkunifiedStatus l_eGetNotificationDataStatus = eFrameworkunifiedStatusFail; + l_eGetNotificationDataStatus = l_pNotificationManager->NPGetPersistentNotificationData( + NTFY_NPPService_UserChange, + (PVOID)&l_tMsg, + sizeof(l_tMsg)); + + if ((eFrameworkunifiedStatusOK != l_eGetNotificationDataStatus) || (l_uiUserNotificationDataSize <= 0)) { + // set default user +#ifdef AGL_PosixBasedOS001LEGACY_USED + strlcpy(l_tMsg.cUsername, DEFAULTUSERNAME, sizeof(l_tMsg.cUsername)); +#endif + } + + l_estatus = SetPersonality(l_pHApp, l_tMsg); + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + l_estatus = eFrameworkunifiedStatusInvldHandle; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return l_estatus; +} + +EFrameworkunifiedStatus SetPersonality(HANDLE l_pHApp, NC_User &f_tMsg) { // NOLINT (runtime/references) + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + if (NULL != l_pnsnpp) { // LCOV_EXCL_BR_LINE 6: l_pnsnpp can't be NULL + // Get the instance of personalization manager + CnotificationpersistentservicePersonalizationManager *l_pNotificationpersistentservicePersonalizationManager = l_pnsnpp->m_pPersonalizationManager; + + if (NULL != l_pNotificationpersistentservicePersonalizationManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationpersistentservicePersonalizationManager can't be NULL + // send msg to all notificationpersistentservice apps that user has change. + // register user change notification + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Personality :: %s", f_tMsg.cUsername); + + if (eFrameworkunifiedStatusOK != (l_estatus = l_pNotificationpersistentservicePersonalizationManager->NotificationpersistentserviceSetPersonality(f_tMsg.cUsername))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Personality not set in Personality Manager :: user : %s", f_tMsg.cUsername); + } else { + // Get the instance of persistence manager + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + + if (NULL != l_pPersistenceManager) { // LCOV_EXCL_BR_LINE 6: l_pPersistenceManager can't be NULL + l_pPersistenceManager->SetUserPersistentPath(f_tMsg.cUsername); + + // save the user persistent notification data + if (eFrameworkunifiedStatusOK != l_pnsnpp->NotificationpersistentserviceLoadPersistentNotificationData(eFrameworkunifiedPersistedStateUserVar)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error while loading user specific notification data."); + } + + // Get instance of notification manager + CNotificationManager *l_pNotificationManager = NULL; + l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + + if (NULL != l_pNotificationManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager can't be NULL + // publish the user change notification + if (eFrameworkunifiedStatusOK != (l_estatus = l_pNotificationManager->NotificationpersistentserviceServiceOnPublishEvent(AppName, NTFY_NPPService_UserChange, (PVOID)&f_tMsg, sizeof(f_tMsg)))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in publish user change event."); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + } + } + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pNotificationpersistentservicePersonalizationManager is NULL"); // LCOV_EXCL_LINE 6: l_pNotificationpersistentservicePersonalizationManager can't be NULL // NOLINT[whitespace/line_length] + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return l_estatus; +} + +EFrameworkunifiedStatus CsNotificationpersistentserviceNPPStart:: FrameworkunifiedOnExit(CEventDataPtr f_peventdata) { // LCOV_EXCL_START 200: cannot test code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + return eFrameworkunifiedStatusOK; + // LCOV_EXCL_STOP +} + +CsNotificationpersistentserviceShutdownDataSave::CsNotificationpersistentserviceShutdownDataSave(std::string f_strName): CFrameworkunifiedLeafState(f_strName) { +} + +CsNotificationpersistentserviceShutdownDataSave::~CsNotificationpersistentserviceShutdownDataSave() { // LCOV_EXCL_START 200: cannot test code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert +} +// LCOV_EXCL_STOP + +EFrameworkunifiedStatus CsNotificationpersistentserviceShutdownDataSave::FrameworkunifiedOnEntry(CEventDataPtr f_peventdata) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + + HANDLE l_pHApp = FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + m_cShutdownRequestor = l_cMsgSource; + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "NS_NPP received STOP message from %s.", l_cMsgSource); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + if (NULL != l_pnsnpp) { // LCOV_EXCL_BR_LINE 6: can't be NULL + CShutDownMsgData *l_pMsgData = dynamic_cast(f_peventdata.get()); + CHKNULL(l_pMsgData); + + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Shutdown Type=%d, Data received with shutdown message:: %x", + l_pMsgData->m_eShutdownType, l_pMsgData->m_uiMsgData); + + // save the persistent data on shutdown + if (eFrameworkunifiedStatusOK != l_pnsnpp->NotificationpersistentservicePersistAll(l_pMsgData->m_eShutdownType, l_pMsgData->m_uiMsgData)) { // LCOV_EXCL_BR_LINE 6: always return ok // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in NotificationpersistentserviceOnSavePersistentData"); // LCOV_EXCL_LINE 6: always return ok + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return eFrameworkunifiedStatusOK; +} + +EFrameworkunifiedStatus CsNotificationpersistentserviceShutdownDataSave:: FrameworkunifiedOnExit(CEventDataPtr f_peventdata) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + try { + HANDLE l_pHApp = FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + CHKNULL(l_pnsnpp); + + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + CHKNULL(l_pPersistenceManager); + + l_pPersistenceManager->ResetPersistFlag(); + + // before sending shutdown ack, synchronize all the modified block buffers by NPPService for writing + l_pnsnpp->Syncfs(); + + // Send shutdown ack response to requester + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Sending shutdown complete message to requestor %s.", + m_cShutdownRequestor.c_str()); + HANDLE hMq = FrameworkunifiedMcOpenSender(l_pHApp, m_cShutdownRequestor.c_str()); + if (NULL != hMq) { // LCOV_EXCL_BR_LINE 4: NSFW error case. + if (eFrameworkunifiedStatusOK != FrameworkunifiedSendMsg(hMq, NPS_NPP_STOP_ACK, 0, NULL)) { // LCOV_EXCL_BR_LINE 4: NSFW error case + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error sending shutdown complete message to requestor %s.", + m_cShutdownRequestor.c_str()); + // LCOV_EXCL_STOP + } + FrameworkunifiedMcClose(hMq); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in OpenSender for requestor %s.", m_cShutdownRequestor.c_str()); // LCOV_EXCL_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eFrameworkunifiedStatusOK; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnRegisterPersistentFile +/// The state machine executes this transition when event for registering persistent file tag is +/// received. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnRegisterPersistentFile) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + CHKNULL(f_pSourceState); + NC_RegisterPersistentFileMsg l_tMsg = {}; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + + + if (NULL != l_pPersistenceManager && NULL != l_cMsgSource) { // LCOV_EXCL_BR_LINE 6: l_pPersistenceManager and l_cMsgSource can't be NULL // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK == FrameworkunifiedGetMsgDataOfSize(l_pHApp, static_cast(&l_tMsg), sizeof(l_tMsg), eSMRRelease)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + std::string l_cName; + l_cName = l_tMsg.cFileTag; + + if (eFrameworkunifiedStatusOK != l_pPersistenceManager->NotificationpersistentserviceRegister(l_cMsgSource, // LCOV_EXCL_BR_LINE 6: always return ok + l_tMsg.cFileTag, + ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE, + // l_tMsg.eRegisterType, + l_tMsg.bIsUserFile)) { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in Registering Persitence File :: %s", l_tMsg.cFileTag); // LCOV_EXCL_LINE 6: always return ok // NOLINT[whitespace/line_length] + } + + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Registered File %s as TO BE PERSISTED for %s", + l_tMsg.cFileTag, l_cMsgSource); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't register persistent file. Invalid message size received."); // LCOV_EXCL_LINE 6: l_pPersistenceManager and l_cMsgSource can't be NULL // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't register persistent file. l_pPersistenceManager is NULL"); // LCOV_EXCL_LINE 6: l_pPersistenceManager and l_cMsgSource can't be NULL // NOLINT[whitespace/line_length] + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnReleasePersistentFile +/// The state machine executes this transition when event for releasing persistent file tag is +/// received. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnReleasePersistentFile) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + + // Check if persistence has been disabled than return immediately + if (TRUE == CPersistenceManager::m_bPersistenceDisabled) { // LCOV_EXCL_BR_LINE 6: custom command line options + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + return f_pSourceState; // LCOV_EXCL_LINE 6: custom command line options + } + + CHKNULL(f_pSourceState); + NC_ReleasePersistentFileMsg l_tMsg = {}; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + // get the instance of persistence manager + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + // get the instance of persistence manager + CnotificationpersistentservicePersonalizationManager *l_pNotificationpersistentservicePersonalizationManager = l_pnsnpp->m_pPersonalizationManager; + + if (NULL != l_pPersistenceManager && NULL != l_cMsgSource && NULL != l_pNotificationpersistentservicePersonalizationManager) { // LCOV_EXCL_BR_LINE 6: l_pPersistenceManager, l_cMsgSource and l_pNotificationpersistentservicePersonalizationManager can't be NULL // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK == FrameworkunifiedGetMsgDataOfSize(l_pHApp, static_cast(&l_tMsg), sizeof(l_tMsg), eSMRRelease)) { // LCOV_EXCL_BR_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + // Check if the filetag is registered as user specific persistence + if (TRUE == l_pPersistenceManager->IsUserPersistence(l_tMsg.cFileTag, ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE)) { + if (!l_pNotificationpersistentservicePersonalizationManager->NotificationpersistentserviceIsValidPersonality(l_tMsg.cUsername)) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; + } + } + + if (eFrameworkunifiedStatusOK != l_pPersistenceManager->NotificationpersistentserviceRelease(l_cMsgSource, + l_tMsg.cFileTag, + l_tMsg.cFilePath, + l_tMsg.eFrameworkunifiedReleaseType, // NOLINT (readability/naming) + ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE, + l_tMsg.cUsername)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in releasing persitence file :: %s", l_tMsg.cFileTag); + } + + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Release file %s to tag %s for source %s", + l_tMsg.cFilePath, l_tMsg.cFileTag, l_cMsgSource); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't release persistent file. Invalid message size received"); // LCOV_EXCL_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't release persistent file. l_pPersistenceManager is NULL"); // LCOV_EXCL_LINE 6: l_pPersistenceManager, l_cMsgSource and l_pNotificationpersistentservicePersonalizationManager can't be NULL // NOLINT[whitespace/line_length] + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnLoadPersistentFile +/// The state machine executes this transition when event for loading persistent file is received. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnLoadPersistentFile) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + CHKNULL(f_pSourceState); + NC_LoadPersistedFileMsg l_tMsg = {}; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + CnotificationpersistentservicePersonalizationManager *l_pNotificationpersistentservicePersonalizationManager = l_pnsnpp->m_pPersonalizationManager; + // get the instance of persistence manager + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + + if (NULL != l_pPersistenceManager && NULL != l_cMsgSource && NULL != l_pNotificationpersistentservicePersonalizationManager) { // LCOV_EXCL_BR_LINE 6: l_pPersistenceManager, l_cMsgSource and l_pNotificationpersistentservicePersonalizationManager can't be NULL // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK == FrameworkunifiedGetMsgDataOfSize(l_pHApp, static_cast(&l_tMsg), sizeof(l_tMsg), eSMRRelease)) { // LCOV_EXCL_BR_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Load file %s that was PERSISTED by %s with tag %s", + l_tMsg.cFilePath, l_cMsgSource, l_tMsg.cFileTag); + + // Check if the filetag is registered as user specific persistence + if (TRUE == l_pPersistenceManager->IsUserPersistence(l_tMsg.cFileTag, ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE)) { + if (!l_pNotificationpersistentservicePersonalizationManager->NotificationpersistentserviceIsValidPersonality(l_tMsg.cUsername)) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; + } + } + + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + NC_LoadPersistedAck l_tMsgAck = {}; + + HANDLE l_hMq = FrameworkunifiedMcOpenSender(l_pHApp, l_cMsgSource); + + if (NULL != l_hMq) { // LCOV_EXCL_BR_LINE 4: NSFW error case + //// Check if persistence has been disabled than send positive acknowledgement to the application + if (TRUE == CPersistenceManager::m_bPersistenceDisabled) { // LCOV_EXCL_BR_LINE 6: custom command line options // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: custom command line options + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_tMsgAck.eStatus = eFrameworkunifiedStatusOK; +#ifdef AGL_PosixBasedOS001LEGACY_USED + strlcpy(l_tMsgAck.cTag, l_tMsg.cFileTag, sizeof(l_tMsgAck.cTag)); +#endif + + // send ack to requester + if (eFrameworkunifiedStatusOK != (l_estatus = FrameworkunifiedSendMsg(l_hMq, NPS_GET_PERS_FILE_ACK, sizeof(l_tMsgAck), &l_tMsgAck))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: FrameworkunifiedSendMsg returned l_estatus=%d", l_estatus); + } + // LCOV_EXCL_STOP + } else { + if (eFrameworkunifiedStatusOK != (l_estatus = l_pPersistenceManager->NotificationpersistentserviceLoad(l_cMsgSource, + l_tMsg.cFileTag, + l_tMsg.cFilePath, + ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE, + l_tMsg.cUsername))) { + if (eFrameworkunifiedStatusFileLoadSuccess == l_estatus) { // LCOV_EXCL_BR_LINE 6: l_estatus can't be eFrameworkunifiedStatusFileLoadSuccess // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_tMsgAck.eStatus = eFrameworkunifiedStatusOK; // LCOV_EXCL_LINE 6: l_estatus can't be eFrameworkunifiedStatusFileLoadSuccess + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in Loading Persitence File :: %s", l_tMsg.cFileTag); + + // return error to requester + l_tMsgAck.eStatus = l_estatus; + } + + std::strncpy(l_tMsgAck.cTag, l_tMsg.cFileTag, (MAX_PATH_LENGTH - 1)); + + // send ack to requester + if (eFrameworkunifiedStatusOK != (l_estatus = FrameworkunifiedSendMsg(l_hMq, NPS_GET_PERS_FILE_ACK, sizeof(l_tMsgAck), &l_tMsgAck))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: FrameworkunifiedSendMsg returned l_estatus=%d", l_estatus); // LCOV_EXCL_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + } + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "NPS_GET_PERS_FILE_ACK is sent to %s. File load status: %d, " + "message sent status: %d ", l_cMsgSource, l_tMsgAck.eStatus, l_estatus); + } + } + + FrameworkunifiedMcClose(l_hMq); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + // catastrophic failure! + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "McOpenSender failed for %s", l_cMsgSource); + // LCOV_EXCL_STOP + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't load persistent file. Invalid message size received."); // LCOV_EXCL_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't load persistent file. l_pNotificationManager is NULL"); // LCOV_EXCL_LINE 6: l_pPersistenceManager, l_cMsgSource and l_pNotificationpersistentservicePersonalizationManager can't be NULL // NOLINT[whitespace/line_length] + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnRegisterPersistentFolder +/// The state machine executes this transition when event for registering persistent folder tag is +/// received. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnRegisterPersistentFolder) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + CHKNULL(f_pSourceState); + NC_RegisterPersistentFolderMsg l_tMsg = {}; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + + if (NULL != l_pPersistenceManager && NULL != l_cMsgSource) { // LCOV_EXCL_BR_LINE 6: l_pPersistenceManager and l_cMsgSource can't be NULL // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK == FrameworkunifiedGetMsgDataOfSize(l_pHApp, // LCOV_EXCL_BR_LINE 4: NSFW error case + static_cast(&l_tMsg), + sizeof(l_tMsg), + eSMRRelease)) { + std::string l_cName; + l_cName = l_tMsg.cFolderTag; + + if (eFrameworkunifiedStatusOK != l_pPersistenceManager->NotificationpersistentserviceRegister(l_cMsgSource, // LCOV_EXCL_BR_LINE 6: always return ok + l_tMsg.cFolderTag, + ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER, + // l_tMsg.eRegisterType, + l_tMsg.bIsUserFolder)) { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in Registering Persitence Folder :: %s", l_tMsg.cFolderTag); // LCOV_EXCL_LINE 6: always return ok // NOLINT[whitespace/line_length] + } + + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Registered Folder %s as TO BE PERSISTED for %s", + l_tMsg.cFolderTag, l_cMsgSource); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't register persistent folder. Invalid message size received."); + // LCOV_EXCL_STOP + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't register persistent folder.. l_pPersistenceManager is NULL"); // LCOV_EXCL_LINE 6: l_pPersistenceManager and l_cMsgSource can't be NULL // NOLINT[whitespace/line_length] + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnLoadPersistentFolder +/// The state machine executes this transition when event for loading persistent folder is received. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnLoadPersistentFolder) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + CHKNULL(f_pSourceState); + NC_LoadPersistedFolderMsg l_tMsg = {}; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + CnotificationpersistentservicePersonalizationManager *l_pNotificationpersistentservicePersonalizationManager = l_pnsnpp->m_pPersonalizationManager; + + // get the instance of persistence manager + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + + if (NULL != l_pPersistenceManager && NULL != l_cMsgSource && NULL != l_pNotificationpersistentservicePersonalizationManager) { // LCOV_EXCL_BR_LINE 6: l_pPersistenceManager, l_cMsgSource and l_pNotificationpersistentservicePersonalizationManager can't be NULL // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK == FrameworkunifiedGetMsgDataOfSize(l_pHApp, static_cast(&l_tMsg), sizeof(l_tMsg), eSMRRelease)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Load folder %s that was PERSISTED by %s with tag %s", + l_tMsg.cFolderPath, l_cMsgSource, l_tMsg.cFolderTag); + + // Check if the foldertag is registered as user specific persistence + if (TRUE == l_pPersistenceManager->IsUserPersistence(l_tMsg.cFolderTag, ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER)) { + if (!l_pNotificationpersistentservicePersonalizationManager->NotificationpersistentserviceIsValidPersonality(l_tMsg.cUsername)) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; + } + } + + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + NC_LoadPersistedAck l_tMsgAck = {}; + HANDLE l_hMq = NULL; + l_hMq = FrameworkunifiedMcOpenSender(l_pHApp, l_cMsgSource); + + if (NULL != l_hMq) { // LCOV_EXCL_BR_LINE 4: NSFW error case + //// Check if persistence has been disabled than send positive acknowledgement to the application + if (TRUE == CPersistenceManager::m_bPersistenceDisabled) { // LCOV_EXCL_BR_LINE 6: custom command line options // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: custom command line options + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_tMsgAck.eStatus = eFrameworkunifiedStatusOK; +#ifdef AGL_PosixBasedOS001LEGACY_USED + strlcpy(l_tMsgAck.cTag, l_tMsg.cFolderTag, sizeof(l_tMsgAck.cTag)); +#endif + + // send ack to requester + if (eFrameworkunifiedStatusOK != (l_estatus = FrameworkunifiedSendMsg(l_hMq, + NPS_GET_PERS_FOLDER_ACK, + sizeof(l_tMsgAck), &l_tMsgAck))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: FrameworkunifiedSendMsg returned l_estatus=%d", l_estatus); + } + // LCOV_EXCL_STOP + } else { + if (eFrameworkunifiedStatusOK != (l_estatus = l_pPersistenceManager->NotificationpersistentserviceLoad(l_cMsgSource, + l_tMsg.cFolderTag, + l_tMsg.cFolderPath, + ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER, + l_tMsg.cUsername))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in Loading Persitence Folder :: %s", l_tMsg.cFolderTag); + + // return error to requester + l_tMsgAck.eStatus = l_estatus; + std::strncpy(l_tMsgAck.cTag, l_tMsg.cFolderTag, (MAX_PATH_LENGTH - 1)); + + // send ack to requester + if (eFrameworkunifiedStatusOK != (l_estatus = FrameworkunifiedSendMsg(l_hMq, // LCOV_EXCL_BR_LINE 4: NSFW error case + NPS_GET_PERS_FOLDER_ACK, + sizeof(l_tMsgAck), &l_tMsgAck))) { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: FrameworkunifiedSendMsg returned l_estatus=%d", l_estatus); + // LCOV_EXCL_STOP + } + } + } + FrameworkunifiedMcClose(l_hMq); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't send ack NPS_GET_PERS_FOLDER_ACK. McOpenSender failed for %s ", l_cMsgSource); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't load persistent folder. Invalid message size received."); + // LCOV_EXCL_STOP + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't load persistent folder. l_pNotificationManager is NULL"); // LCOV_EXCL_LINE 6: l_pPersistenceManager, l_cMsgSource and l_pNotificationpersistentservicePersonalizationManager can't be NULL // NOLINT[whitespace/line_length] + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnReleasePersistentFolder +/// The state machine executes this transition when event for releasing persistent folder tag is +/// received. +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnReleasePersistentFolder) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + CHKNULL(f_pSourceState); + + // Check if persistence has been disabled than return immediately + if (TRUE == CPersistenceManager::m_bPersistenceDisabled) { // LCOV_EXCL_BR_LINE 6: custom command line options + // LCOV_EXCL_START 6: custom command line options + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; + // LCOV_EXCL_STOP + } + + NC_ReleasePersistentFolderMsg l_tMsg = {}; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + // get the instance of persistence manager + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + + CnotificationpersistentservicePersonalizationManager *l_pNotificationpersistentservicePersonalizationManager = l_pnsnpp->m_pPersonalizationManager; + + if (NULL != l_pPersistenceManager && NULL != l_cMsgSource && NULL != l_pNotificationpersistentservicePersonalizationManager) { // LCOV_EXCL_BR_LINE 6: l_pPersistenceManager, l_cMsgSource and l_pNotificationpersistentservicePersonalizationManager can't be NULL // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK == FrameworkunifiedGetMsgDataOfSize(l_pHApp, static_cast(&l_tMsg), sizeof(l_tMsg), eSMRRelease)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + // Check if the foldertag is registered as user specific persistence + if (TRUE == l_pPersistenceManager->IsUserPersistence(l_tMsg.cFolderTag, ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER)) { + if (!l_pNotificationpersistentservicePersonalizationManager->NotificationpersistentserviceIsValidPersonality(l_tMsg.cUsername)) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; + } + } + if (eFrameworkunifiedStatusOK != l_pPersistenceManager->NotificationpersistentserviceRelease(l_cMsgSource, + l_tMsg.cFolderTag, + l_tMsg.cFolderPath, + l_tMsg.eFrameworkunifiedReleaseType, // NOLINT (readability/naming) + ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER, + l_tMsg.cUsername)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in releasing persitence folder :: %s", l_tMsg.cFolderTag); + } + + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Release Folder %s to tag %s for source %s", + l_tMsg.cFolderPath, l_tMsg.cFolderTag, l_cMsgSource); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't release persistent folder. Invalid message size received."); + // LCOV_EXCL_STOP + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't release persistent folder. l_pPersistenceManager is NULL"); // LCOV_EXCL_LINE 6: l_pPersistenceManager, l_cMsgSource and l_pNotificationpersistentservicePersonalizationManager can't be NULL // NOLINT[whitespace/line_length] + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPGetReadyStatus +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPGetReadyStatus) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + + CHKNULL(f_pSourceState); + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + HANDLE l_hMq = FrameworkunifiedMcOpenSender(l_pHApp, l_cMsgSource); + if (NULL != l_hMq) { // LCOV_EXCL_BR_LINE 4: NSFW error case + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + // send ack to requester + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedSendMsg(l_hMq, NPS_GET_READYSTATUS_ACK, 0, NULL))) { // LCOV_EXCL_BR_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __PRETTY_FUNCTION__, "NPP ready status sent to %s.", l_cMsgSource); + } else { + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "Error sending NPS_GET_READYSTATUS_ACK to %s, status: %d", l_cMsgSource, + l_estatus); + // LCOV_EXCL_STOP + } + + FrameworkunifiedMcClose(l_hMq); + l_hMq = NULL; + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + // catastrophic failure! + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "McOpenSender failed for %s ", l_cMsgSource); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPRegisterImmediateNotifications) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + CHKNULL(f_pSourceState); + NC_register_multiple_immediate_notif_msg *l_pMsg = NULL; + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + + // get app name of message source + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + + if (NULL != l_pNotificationManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager can't be NULL + UI_32 l_uiMsgLength = FrameworkunifiedGetMsgLength(l_pHApp); + + if (l_uiMsgLength <= 0) { // LCOV_EXCL_BR_LINE 6: l_uiMsgLength must be greater than 0 + // LCOV_EXCL_START 6: l_uiMsgLength must be greater than 0 + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't register immediate persistence notification from source %s. Invalid message length.", + l_cMsgSource); + // LCOV_EXCL_STOP + } else { + std::vector l_vData = std::vector(l_uiMsgLength); + + // get the received data + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &l_vData[0], static_cast(l_vData.size()), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + l_pMsg = reinterpret_cast(&l_vData[0]); + + if (NULL != l_pMsg) { // LCOV_EXCL_BR_LINE 5: reinterpret_cast's error case. + NC_register_immediate_notif_msg *l_pEventInfo = NULL; + UI_32 l_uiCount; + // register all the notifications + for (l_uiCount = 0 ; l_uiCount < l_pMsg->numNotifications; ++l_uiCount) { + l_pEventInfo = &l_pMsg->notifierList[l_uiCount]; + + if (NULL != l_pEventInfo) { // LCOV_EXCL_BR_LINE 6: l_pEventInfo can't be NULL + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Register immediate persistence notification: " + "NotificationName[%d] = %s, data length = %d ", + l_uiCount, l_pEventInfo->notificationName, l_pEventInfo->maxLength); + + if (eFrameworkunifiedStatusOK != l_pNotificationManager->NotificationpersistentserviceServiceOnRegisterEvents(l_cMsgSource, + l_pEventInfo->notificationName, + l_pEventInfo->maxLength, + l_pEventInfo->persType, + l_pEventInfo->delay)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error in NotificationpersistentserviceServiceOnRegisterEvents :: %s", l_pEventInfo->notificationName); + } + } else { + // LCOV_EXCL_START 6: l_pEventInfo can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't register immediate persistence notification from source %s. l_pEventInfo is NULL", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } + } else { + // LCOV_EXCL_START 5: reinterpret_cast's error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't register immediate persistence notification from source %s. Invalid src mq", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't register immediate persistence notification from source %s, " + "Error getting message data, status: 0x%x", + l_cMsgSource, l_estatus); + // LCOV_EXCL_STOP + } + } + } else { + // LCOV_EXCL_START 6: l_pNotificationManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't register immediate persistence notification from source %s. " + "l_pNotificationManager is NULL", l_cMsgSource); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPClearPersistedData +/// Deletes NPS Persistent Data and sends the ack back to requester +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPClearPersistedData) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + + // requeter MsgQ handle for sending Ack + HANDLE hRequesterAck = NULL; + + // Application Handle + HANDLE l_pHApp = NULL; + + // Received request data + NC_ClearPersistedDataReq l_tMsg = {}; + + // Ack structure + NC_ClearPersisteDatadAck l_tMsgAck = {}; + + // requester name + PCSTR pRequester = NULL; + + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + + l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + CHKNULL(l_pnsnpp); + + pRequester = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(pRequester); + + if (sizeof(NC_ClearPersistedDataReq) == FrameworkunifiedGetMsgLength(l_pHApp)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, (PVOID)(&l_tMsg), sizeof(NC_ClearPersistedDataReq), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Request for deleting the persistent data of type %d received from %s", + l_tMsg.ePersistenceData, pRequester); + + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + CHKNULL(l_pPersistenceManager); + + l_estatus = l_pPersistenceManager->ClearPersistenceData(l_tMsg.ePersistenceData); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedGetMsgDataOfSize Error"); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't delete persistent data. Invalid message size received."); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + f_pSourceState = NULL; + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + + // sending acknowledgement to the requester + + // create the requestor handle to send the ack + hRequesterAck = FrameworkunifiedMcOpenSender(l_pHApp, + pRequester); + + if (NULL != hRequesterAck) { // LCOV_EXCL_BR_LINE 4: NSFW error case + // set the status + l_tMsgAck.eStatus = l_estatus; + + // send NC_ClearPersisteDatadAck to the requester + if (eFrameworkunifiedStatusOK != FrameworkunifiedSendMsg(hRequesterAck, // LCOV_EXCL_BR_LINE 4: NSFW error case + NPS_DELETE_PERSISTED_DATA_ACK, + sizeof(l_tMsgAck), + &l_tMsgAck)) { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Error sending NPS_GET_PERS_FILE_ACK message to %s", pRequester); + // LCOV_EXCL_STOP + } + + // close handle + FrameworkunifiedMcClose(hRequesterAck); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "FrameworkunifiedMcOpenSender failed for %s ", pRequester); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPSetDefaultPersistentData +/// Sets the default value of the persistent notification +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPSetDefaultPersistentData) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + CHKNULL(f_pSourceState); + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CHKNULL(l_pNotificationpersistentserviceHSM); + + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + CHKNULL(l_pnsnpp); + + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + + if (NULL != l_pNotificationManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager can't be NULL + UI_32 l_uiMsgLength = FrameworkunifiedGetMsgLength(l_pHApp); + + CHAR l_cNotificationName[MAX_SYS_INFO_SIZE] = {}; + + // retrieve notification name + FrameworkunifiedGetSystemInfo(l_pHApp, l_cNotificationName); + + if (0 != std::strlen(l_cNotificationName)) { // LCOV_EXCL_BR_LINE 6: double check, l_cNotificationName can't be empty // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, + "Set default value request for Notification:: %s from :: %s", l_cNotificationName, + l_cMsgSource); + + if (0 != l_uiMsgLength) { + std::vector pMsgData = std::vector(l_uiMsgLength); + + // get the received data + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &pMsgData[0], static_cast(pMsgData.size()), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + // set the default notification data + if (eFrameworkunifiedStatusOK != l_pNotificationManager->NotificationpersistentserviceSetDefaultPersistentNotificationData(l_cNotificationName, + (PVOID)&pMsgData[0], + l_uiMsgLength)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error in NotificationpersistentserviceSetDefaultPersistentNotificationData :: %s", l_cNotificationName); + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Unable to set default persistent notification data for %s, " + "Error retrieving data from message, status: 0x%x", + l_cNotificationName, l_estatus); + // LCOV_EXCL_STOP + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Not setting default persistent notification data for %s, Data length received is %d", + l_cNotificationName, l_uiMsgLength); + } + } else { + // LCOV_EXCL_START 6: double check, l_cNotificationName can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Unable to Set DefaultPersistentNotificationData from source %s, Notification name is blank", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: l_pNotificationManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't set default value for notification from source %s, l_pNotificationManager is NULL", l_cMsgSource); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPSetNotfnPersistentType +/// Sets the persist type of notification +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPSetNotfnPersistentType) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + CHKNULL(f_pSourceState); + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CHKNULL(l_pNotificationpersistentserviceHSM); + + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + CHKNULL(l_pnsnpp); + + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + CHAR l_cNotificationName[MAX_SYS_INFO_SIZE] = {}; + + // retrieve notification name + FrameworkunifiedGetSystemInfo(l_pHApp, + l_cNotificationName); + + // get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + + if (NULL != l_pNotificationManager && 0 != std::strlen(l_cNotificationName)) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager can't be NULL, l_cNotificationName can't be empty // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Set persist type request for Notification:: %s", l_cNotificationName); + + EFrameworkunifiedPersistCategory ePersistCategory = eFrameworkunifiedUserData; + + // get the received data + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &ePersistCategory, sizeof(EFrameworkunifiedPersistCategory), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + // set the notification persist type + if (eFrameworkunifiedStatusOK != (l_estatus = l_pNotificationManager->NotificationpersistentserviceSetPersistentCategory(l_cNotificationName, // LCOV_EXCL_BR_LINE 6: always return ok // NOLINT[whitespace/line_length] + ePersistCategory))) { + // LCOV_EXCL_START 6: always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in Setting PersistentType for notification :: %s, Status: 0x%x", + l_cNotificationName, l_estatus); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error in getting the PersistentType message data for notification :: %s, Status: 0x%x", + l_cNotificationName, l_estatus); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: l_pNotificationManager can't be NULL, l_cNotificationName can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't set persist type for notification :: %s", l_cNotificationName); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPSetFilePersistentType +/// Sets the persist type of file +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPSetFilePersistentType) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + CHKNULL(f_pSourceState); + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CHKNULL(l_pNotificationpersistentserviceHSM); + + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + CHKNULL(l_pnsnpp); + + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get instance of persistence manager + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + + if (NULL != l_pPersistenceManager) { // LCOV_EXCL_BR_LINE 6: l_pPersistenceManager can't be NULL + NC_SetFilePersistType l_tMsg = {}; + + // get the received data + if (eFrameworkunifiedStatusOK == FrameworkunifiedGetMsgDataOfSize(l_pHApp, static_cast(&l_tMsg), sizeof(l_tMsg), eSMRRelease)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + if (0 != std::strlen(l_tMsg.cTag)) { // LCOV_EXCL_BR_LINE 6: double check, l_tMsg.cTag can't be empty + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, + "Set persist type request for file tag:: %s from %s", l_tMsg.cTag, l_cMsgSource); + + // set the file persist type + if (eFrameworkunifiedStatusOK != l_pPersistenceManager->NotificationpersistentserviceSetPersistentCategory(l_cMsgSource, + l_tMsg.cTag, + l_tMsg.ePersistType, + ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error in Setting FilePersistentType for tag:: %s for request from:: %s", l_tMsg.cTag, + l_cMsgSource); + } + } else { + // LCOV_EXCL_START 6: double check, l_tMsg.cTag can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "set file persistent type request for NULL file tag from source:: %s", l_cMsgSource); + // LCOV_EXCL_STOP + } + } + } else { + // LCOV_EXCL_START 6: l_pPersistenceManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't process request for setting persist type for file from source: %s, l_pPersistenceManager is NULL", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPSetFolderPersistentType +/// Sets the persist type of folder +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPSetFolderPersistentType) { + try { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + CHKNULL(f_pSourceState); + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CHKNULL(l_pNotificationpersistentserviceHSM); + + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + CHKNULL(l_pnsnpp); + + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get instance of persistence manager + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + + if (NULL != l_pPersistenceManager) { // LCOV_EXCL_BR_LINE 6: l_pPersistenceManager can't be NULL + NC_SetFolderPersistType l_tMsg = {}; + + // get the received data + if (eFrameworkunifiedStatusOK == FrameworkunifiedGetMsgDataOfSize(l_pHApp, static_cast(&l_tMsg), sizeof(l_tMsg), eSMRRelease)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + if (0 != std::strlen(l_tMsg.cTag)) { // LCOV_EXCL_BR_LINE 6: double check, l_tMsg.cTag can't be empty + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Set persist type request for folder tag:: %s", l_tMsg.cTag); + + // set the file persist type + if (eFrameworkunifiedStatusOK != l_pPersistenceManager->NotificationpersistentserviceSetPersistentCategory(l_cMsgSource, + l_tMsg.cTag, + l_tMsg.ePersistType, + ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error in Setting FolderPersistentType for tag:: %s for request from:: %s", l_tMsg.cTag, + l_cMsgSource); + } + } else { + // LCOV_EXCL_START 6: double check, l_tMsg.cTag can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "set file persistent type request for NULL folder tag from source:: %s", l_cMsgSource); + // LCOV_EXCL_STOP + } + } + } else { + // LCOV_EXCL_START 6: l_pPersistenceManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't process request for setting persist type for folder from source: %s, l_pPersistenceManager is NULL", + l_cMsgSource); + // LCOV_EXCL_STOP + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPShutdown +/// Internal transition when NPP receives shutdown message +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPShutdown) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + try { + CHKNULL(f_pSourceState); + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + NC_StopMsgData l_tStopMsgData = {}; + + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + if (eFrameworkunifiedStatusOK == FrameworkunifiedGetMsgDataOfSize(l_pHApp, static_cast(&l_tStopMsgData), sizeof(l_tStopMsgData), eSMRRelease)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + // make a transition to sNotificationpersistentserviceShutdownDataSave state and pass the message data through event + CShutDownMsgData *l_pMsgData = new(std::nothrow) CShutDownMsgData(EVENT(evNPShutdownDataSave), + l_tStopMsgData.eShutdownType, + l_tStopMsgData.uiStopMsgData); + CHKNULL(l_pMsgData); + + CEventDataPtr l_pData(l_pMsgData); + f_pSourceState->FrameworkunifiedPostEvent(l_pData); + + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Shutdown Message received from %s with data: %d", l_cMsgSource, + l_tStopMsgData.uiStopMsgData); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't process shutdown request from:: %s, Invalid message data", l_cMsgSource); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + f_pSourceState = NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnNPNorDataSaveAck +/// Internal transition when NPP receives shutdown ack message nor worker thread +//////////////////////////////////////////////////////////////////////////////////////////////////// +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPNorDataSaveAck) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + try { + // data received with ack + UI_32 l_uiPersistCategoryFlag = 0; + + CHKNULL(f_pSourceState); + + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CHKNULL(l_pNotificationpersistentserviceHSM); + + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + CHKNULL(l_pnsnpp); + + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get instance of persistence manager + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + CHKNULL(l_pPersistenceManager); + + l_pPersistenceManager->SetImmediateDataPersistedStatus(TRUE); + + if (eFrameworkunifiedStatusOK == FrameworkunifiedGetMsgDataOfSize(l_pHApp, static_cast(&l_uiPersistCategoryFlag), sizeof(l_uiPersistCategoryFlag), eSMRRelease)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "ShutdownAck received from %s with data: %d", l_cMsgSource, + l_uiPersistCategoryFlag); + } + + // depending on the flag delete the persisted data from persistent memory + // which are not to be persisted during shutdown + l_pnsnpp->DeletePersistedDataFolder(l_uiPersistCategoryFlag); + + if (TRUE == l_pPersistenceManager->HaveAllReleaseRequestsPersisted()) { // LCOV_EXCL_BR_LINE 6: always return ok + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "All release requests are processed."); + f_pSourceState->FrameworkunifiedPostEvent(EVENT(evIdle)); + } + } catch (std::exception &e) { // LCOV_EXCL_START 5: exception error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + f_pSourceState = NULL; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +CsNotificationpersistentservicePersistenceReady::CsNotificationpersistentservicePersistenceReady(std::string f_strName): CFrameworkunifiedLeafState(f_strName) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); +} + +CsNotificationpersistentservicePersistenceReady::~CsNotificationpersistentservicePersistenceReady() { // LCOV_EXCL_START 200: cannot test code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); +} +// LCOV_EXCL_STOP + +EFrameworkunifiedStatus CsNotificationpersistentservicePersistenceReady::FrameworkunifiedOnEntry(CEventDataPtr f_peventdata) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + + HANDLE l_pHApp = FrameworkunifiedGetAppHandle(); + + if (NULL != l_pHApp) { // LCOV_EXCL_BR_LINE 4: NSFW error case. + HANDLE l_hMq = FrameworkunifiedMcOpenSender(l_pHApp, g_csendreadyackto); + + if (NULL != l_hMq) { // LCOV_EXCL_BR_LINE 4: NSFW error case. + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + // send ack to requester + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedSendMsg(l_hMq, NPS_NPP_READY_EVENT, 0, NULL))) { // LCOV_EXCL_BR_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __PRETTY_FUNCTION__, "NPP ready status sent to %s.", g_csendreadyackto); + } else { + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "Error sending NPS_NPP_READY_EVENT to %s, status: %d", g_csendreadyackto, + l_estatus); + // LCOV_EXCL_STOP + } + FrameworkunifiedMcClose(l_hMq); + l_hMq = NULL; + } else { + // catastrophic failure! + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "McOpenSender failed for %s ", g_csendreadyackto); // LCOV_EXCL_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return eFrameworkunifiedStatusOK; +} + +EFrameworkunifiedStatus CsNotificationpersistentservicePersistenceReady::FrameworkunifiedOnExit(CEventDataPtr f_peventdata) { // LCOV_EXCL_START 200: cannot test code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return eFrameworkunifiedStatusOK; + // LCOV_EXCL_STOP +} + +#ifdef NPP_PROFILEINFO_ENABLE + +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPProfileNotifications) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + try { + CHKNULL(f_pSourceState); + + // get the application handle + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + // get the statemachine pointer of application + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + CHKNULL(l_pnsnpp); + + // get the message source name + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get the message queue handle for sending the response + HANDLE hSrcMqHandle = FrameworkunifiedMcOpenSender(l_pHApp, l_cMsgSource); + CHKNULL(hSrcMqHandle); + + // get instance of notification manager + CNotificationManager *l_pNotificationManager = l_pnsnpp->m_pNotificationManager; + CHKNULL(l_pNotificationManager); + + std::string l_cNotificationProfileInfo = ""; + + // get the data from notification manager + if (eFrameworkunifiedStatusOK == l_pNotificationManager->GetNotificationProfilingData(l_cNotificationProfileInfo)) { + UI_32 l_uiLength = l_cNotificationProfileInfo.size(); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "FrameworkunifiedSendMsg NPS_PROFILE_NOTIFICATION_RESP Msg Length: %d", l_uiLength); + + PCHAR l_pData = new CHAR[l_uiLength]; + std::memset(l_pData, '0', l_uiLength); + + std::strncpy(l_pData, l_cNotificationProfileInfo.c_str(), l_cNotificationProfileInfo.size()); + + if (eFrameworkunifiedStatusOK != FrameworkunifiedSendMsg(hSrcMqHandle, + NPS_PROFILE_NOTIFICATION_RESP, + l_uiLength, + l_pData)) { + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, + "FrameworkunifiedSendMsg NPS_PROFILE_NOTIFICATION_RESP for Notification Profiling failed."); + } + + delete[] l_pData; + } else { + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Failed to get Notification profiling data from NSNPP."); + } + } catch (std::exception &e) { + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + f_pSourceState = NULL; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +IMPLEMENT_INTERNALTRANSITION(NotificationpersistentserviceOnNPProfilePersistence) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "+"); + try { + CHKNULL(f_pSourceState); + + // get the application handle + HANDLE l_pHApp = f_pSourceState->FrameworkunifiedGetAppHandle(); + CHKNULL(l_pHApp); + + // get the statemachine pointer of application + CFrameworkunifiedHSM *l_pNotificationpersistentserviceHSM = FrameworkunifiedGetStateMachine(l_pHApp); + CNSNPP *l_pnsnpp = static_cast(l_pNotificationpersistentserviceHSM); + CHKNULL(l_pnsnpp); + + // get the message source name + PCSTR l_cMsgSource = FrameworkunifiedGetMsgSrc(l_pHApp); + CHKNULL(l_cMsgSource); + + // get the message queue handle for sending the response + HANDLE hSrcMqHandle = FrameworkunifiedMcOpenSender(l_pHApp, l_cMsgSource); + CHKNULL(hSrcMqHandle); + + // get instance of persistence manager + CPersistenceManager *l_pPersistenceManager = l_pnsnpp->m_pPersistenceManager; + + CHKNULL(l_pPersistenceManager); + + std::string l_cPersistenceProfileInfo = ""; + + if (eFrameworkunifiedStatusOK == l_pPersistenceManager->GetPersistenceProfilingData(l_cPersistenceProfileInfo)) { + UI_32 l_uiLength = l_cPersistenceProfileInfo.size(); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "FrameworkunifiedSendMsg NPS_PROFILE_PERSISTENCE_RESP Msg Length: %d", l_uiLength); + + PCHAR l_pData = new CHAR[l_uiLength]; + std::memset(l_pData, '0', l_uiLength); + + std::strncpy(l_pData, l_cPersistenceProfileInfo.c_str(), l_cPersistenceProfileInfo.size()); + + if (eFrameworkunifiedStatusOK != FrameworkunifiedSendMsg(hSrcMqHandle, + NPS_PROFILE_PERSISTENCE_RESP, + l_uiLength, + l_pData)) { + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "FrameworkunifiedSendMsg NPS_PROFILE_PERSISTENCE_RESP for Persistence Profiling failed."); + } + + delete[] l_pData; + } + } catch (std::exception &e) { + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Exception %s", e.what()); + f_pSourceState = NULL; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __PRETTY_FUNCTION__, "-"); + return f_pSourceState; +} + +#endif diff --git a/service/native/notification_persistent_service/server/src/notificationpersistentservice_application.cpp b/service/native/notification_persistent_service/server/src/notificationpersistentservice_application.cpp new file mode 100755 index 0000000..c1b97f9 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/notificationpersistentservice_application.cpp @@ -0,0 +1,258 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief +/// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include +#include +#include +#include + +#include "app_states.h" +#include "ns_npp.h" +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_persistence_manager.h" + +using std::malloc; + +#ifdef NPP_PROFILEINFO_ENABLE +#include "ns_npp_profiling_protocols_internal.h" +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Function : FrameworkunifiedOnInitialization +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus FrameworkunifiedOnInitialization(HANDLE happ) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != happ) { // LCOV_EXCL_BR_LINE 4: happ can't be null + FrameworkunifiedProtocolEvent ns_npp_protocol_handlers[] = { + {NPS_REGISTER_EV_REQ, EVENT(evNPRegisterNotifications)}, + {NPS_PUBLISH_EV_REQ, EVENT(evNPPublishNotification)}, + {NPS_SUBSCRIBE_TO_EV_REQ, EVENT(evNPSubscribeToNotification)}, + {NPS_BATCH_SUBSCRIBE_TO_EV_REQ, EVENT(evNPSubscribeToNotifications)}, + {NPS_UNSUBSCRIBE_FROM_EV_REQ, EVENT(evNPUnSubscribeFromNotification)}, + {NPS_UNREGISTER_EV_REQ, EVENT(evNPUnRegisterNotifications)}, + {NPS_GET_PERS_DATA_REQ, EVENT(evNPReadPersistedData)}, + {NPS_SET_PERSIST_FILE_PATH_REQ, EVENT(evNPRegisterPersistentFile)}, + {NPS_RELEASE_PERS_FILE_REQ, EVENT(evNPReleasePersistentFile)}, + {NPS_GET_PERS_FILE_REQ, EVENT(evNPLoadPersistentFile)}, + {NPS_SET_PERSIST_FOLDER_PATH_REQ, EVENT(evNPRegisterPersistentFolder)}, + {NPS_GET_PERS_FOLDER_REQ, EVENT(evNPLoadPersistentFolder)}, + {NPS_RELEASE_PERS_FOLDER_REQ, EVENT(evNPReleasePersistentFolder)}, + {NPS_CHANGE_PERSONALITY_REQ, EVENT(evUserChange)}, + {NPS_NPP_STOP_REQ, EVENT(evShutdown)}, + {NPS_BATCH_UNSUBSCRIBE_FROM_EV_REQ, EVENT(evNPUnSubscribeFromNotifications)}, + {NPS_GET_READYSTATUS_REQ, EVENT(evNPGetReadyStatus)}, + {NPS_REGISTER_NOR_EV_REQ, EVENT(evNPRegisterImmediateNotifications)}, + {NPS_DELETE_PERSISTED_DATA_REQ, EVENT(evNPClearPersistedData)}, + {NPS_SET_DEFAULT_PERS_DATA, EVENT(evNPSetDefaultPersistentData)}, + {NPS_SET_NOTFN_PERSISTENT_TYPE, EVENT(evNPSetNotfnPersistentType)}, + {NPS_SET_FILE_PERSISTENT_TYPE, EVENT(evNPSetFilePersistentType)}, + {NPS_SET_FOLDER_PERSISTENT_TYPE, EVENT(evNPSetFolderPersistentType)}, + {NPS_SYNCHRONOUS_WRITE_NOTIFY_REQ, EVENT(evNPPublishImmediateNotification)}, + {NPS_NPP_SYNC_REQ, EVENT(evNPPersistentSync)} + }; + +#ifdef NPP_PROFILEINFO_ENABLE + + FrameworkunifiedProtocolEvent ns_npp_profile_protocol_handlers[] = { + {NPS_PROFILE_NOTIFICATION_REQ, EVENT(evNPProfileNotification)}, + {NPS_PROFILE_PERSISTENCE_REQ, EVENT(evNPProfilePersistence)}, + }; + + if (eFrameworkunifiedStatusOK == FrameworkunifiedAttachHSMEventsToDispatcher(happ, + "NSProfileUtil", + ns_npp_profile_protocol_handlers, + _countof(ns_npp_profile_protocol_handlers))) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Profile info messages are attached to events"); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Failed to attach profile info messages to events"); + } + +#endif + + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedAttachHSMEventsToDispatcher(happ, FRAMEWORKUNIFIED_ANY_SOURCE, ns_npp_protocol_handlers, static_cast(_countof(ns_npp_protocol_handlers))))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + CNSNPP *l_pnsnpp = new(std::nothrow) CNSNPP(happ); + if (NULL != l_pnsnpp) { // LCOV_EXCL_BR_LINE 5: new's error case. + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "l_pnsnpp object created"); + + if (eFrameworkunifiedStatusOK == (l_estatus = l_pnsnpp->Init(happ))) { // LCOV_EXCL_BR_LINE 200: can't test + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "l_pnsnpp object initialized"); + + if (eFrameworkunifiedStatusOK == (l_estatus = l_pnsnpp->FrameworkunifiedCreate())) { // LCOV_EXCL_BR_LINE 200: the result of l_pnsnpp->FrameworkunifiedCreate() is always eFrameworkunifiedStatusOK // NOLINT[whitespace/line_length] + FrameworkunifiedSetStateMachine(happ, l_pnsnpp); + + l_pnsnpp->FrameworkunifiedStart(); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "NSNPP statemachine not created, status: 0x%x", l_estatus); // LCOV_EXCL_LINE 200: the result of l_pnsnpp->FrameworkunifiedCreate() is always eFrameworkunifiedStatusOK // NOLINT[whitespace/line_length] + } + } else { + // LCOV_EXCL_START 200: can't test + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pnsnpp object initialization error, status: %d", l_estatus); + + // de-initialize the partially initialize object + l_pnsnpp->DeInit(happ); + + delete l_pnsnpp; + l_pnsnpp = NULL; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 5: malloc's error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pnsnpp object not created"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedAttachHSMEventsToDispatcher Failed Status:0x%x ", l_estatus); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + } else { + // LCOV_EXCL_START 4: happ can't be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusInvldParam; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Application handle happ is NULL"); + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus FrameworkunifiedOnDestroy(HANDLE happ) { // LCOV_EXCL_START 14: Resident process, not called by NSFW + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Function : FrameworkunifiedOnDebugDump +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus FrameworkunifiedOnDebugDump(HANDLE happ) { // LCOV_EXCL_START 7: debug code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "+", __FUNCTION__); + /// << Dump internal tables! + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "-", __FUNCTION__); + return eFrameworkunifiedStatusOK; +} +// LCOV_EXCL_STOP + +EFrameworkunifiedStatus FrameworkunifiedCreateStateMachine(HANDLE happ) { + return eFrameworkunifiedStatusOK; +} + +EFrameworkunifiedStatus FrameworkunifiedSSFrameworkInterface(HANDLE happ) { + return eFrameworkunifiedStatusOK; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Function : FrameworkunifiedOnStart +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus FrameworkunifiedOnStart(HANDLE happ) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "+", __FUNCTION__); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "-", __FUNCTION__); + return eFrameworkunifiedStatusOK; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Function : FrameworkunifiedOnStop +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus FrameworkunifiedOnStop(HANDLE happ) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "+", __FUNCTION__); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "-", __FUNCTION__); + return eFrameworkunifiedStatusOK; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Function : FrameworkunifiedOnPreStart +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus FrameworkunifiedOnPreStart(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "+", __FUNCTION__); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "-", __FUNCTION__); + return eFrameworkunifiedStatusOK; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Function : FrameworkunifiedOnPreStop +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus FrameworkunifiedOnPreStop(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "+", __FUNCTION__); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "-", __FUNCTION__); + return eFrameworkunifiedStatusOK; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Function : FrameworkunifiedOnBackgroundStart +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus FrameworkunifiedOnBackgroundStart(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "+", __FUNCTION__); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "-", __FUNCTION__); + return eFrameworkunifiedStatusOK; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Function : FrameworkunifiedOnBackgroundStop +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus FrameworkunifiedOnBackgroundStop(HANDLE hApp) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "+", __FUNCTION__); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, "-", __FUNCTION__); + return eFrameworkunifiedStatusOK; +} + +extern const FrameworkunifiedDefaultCallbackHandler kDefaultCbHandler = { // NOLINT (readability/naming) + FrameworkunifiedOnInitialization, + FrameworkunifiedOnDestroy, + FrameworkunifiedOnStart, + FrameworkunifiedOnStop, + FrameworkunifiedOnPreStart, + FrameworkunifiedOnPreStop, + FrameworkunifiedOnBackgroundStart, + FrameworkunifiedOnBackgroundStop, + FrameworkunifiedOnDebugDump, + FrameworkunifiedCreateStateMachine, + FrameworkunifiedSSFrameworkInterface +}; // LCOV_EXCL_BR_LINE 10: The final line diff --git a/service/native/notification_persistent_service/server/src/notificationpersistentservice_main.cpp b/service/native/notification_persistent_service/server/src/notificationpersistentservice_main.cpp new file mode 100755 index 0000000..fd963c5 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/notificationpersistentservice_main.cpp @@ -0,0 +1,131 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief +/// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include +#include +#include +#include + +#include +#include +#include + +#include "ns_npp.h" // for static members. Set thread prio. +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_persistence_manager.h" // for static members. Set enable/disable persistence feature. + +const CHAR AppName[] = FRAMEWORKUNIFIED_NS_NPSERVICE; // NOLINT (readability/naming) +CHAR g_csendreadyackto[MAX_QUEUE_NAME_SIZE]; + +CFrameworkunifiedVersion g_FrameworkunifiedVersion(MAJORNO, MINORNO, REVISION); // NOLINT (readability/naming) + +// Argument Parser for NSNPP +EFrameworkunifiedStatus NPPArgumentParser(SI_32 f_iargument, PCHAR f_pargumentvalue); + +FRAMEWORKUNIFIEDLOGPARAM g_FrameworkunifiedLogParams = { // NOLINT (readability/naming) + FRAMEWORKUNIFIEDLOGOPTIONS, + { + ZONE_TEXT_10, ZONE_TEXT_11, ZONE_TEXT_12, + ZONE_TEXT_13, ZONE_TEXT_14, ZONE_TEXT_15, + ZONE_TEXT_16, ZONE_TEXT_17, ZONE_TEXT_18, + ZONE_TEXT_19, ZONE_TEXT_20, ZONE_TEXT_21, + ZONE_TEXT_22, ZONE_TEXT_23, ZONE_TEXT_24, + ZONE_TEXT_25, ZONE_TEXT_26, ZONE_TEXT_27, + ZONE_TEXT_28, ZONE_TEXT_29, ZONE_TEXT_30, + ZONE_TEXT_31, + }, + FRAMEWORKUNIFIEDLOGZONES +}; + +extern const FrameworkunifiedDefaultCallbackHandler kDefaultCbHandler; + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Function : main +//////////////////////////////////////////////////////////////////////////////////////////////////// + +int main(int argc, char *argv[]) { + FRAMEWORKUNIFIED_SET_ZONES(); + CustomCommandLineOptions l_tcmdlineoptions = { "i:e:w:fa:v:", NULL, NPPArgumentParser}; + EFrameworkunifiedStatus l_estatus = FrameworkunifiedDispatcherWithArguments(AppName, argc, argv, &kDefaultCbHandler, &l_tcmdlineoptions); + + return static_cast(l_estatus); +} + +EFrameworkunifiedStatus NPPArgumentParser(SI_32 f_iargument, PCHAR f_pargumentvalue) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + SI_32 l_iTmpArgValue = 0; + switch (f_iargument) { // LCOV_EXCL_BR_LINE 8: cannot test + // Disable Persistence + case 'f': { + CPersistenceManager::m_bPersistenceDisabled = TRUE; + break; + } + case 'i': { + l_iTmpArgValue = atoi(f_pargumentvalue); + if (l_iTmpArgValue > 0) { // LCOV_EXCL_BR_LINE 8: cannot test + CNSNPP::m_siImmediatePersistenceThreadPrio = l_iTmpArgValue; + } + break; + } + case 'e': { + l_iTmpArgValue = atoi(f_pargumentvalue); + if (l_iTmpArgValue > 0) { // LCOV_EXCL_BR_LINE 8: cannot test + CNSNPP::m_siReadThreadPrio = l_iTmpArgValue; + } + break; + } + case 'w': { + l_iTmpArgValue = atoi(f_pargumentvalue); + if (l_iTmpArgValue > 0) { // LCOV_EXCL_BR_LINE 8: cannot test + CNSNPP::m_siWriteThreadPrio = l_iTmpArgValue; + } + break; + } + case 'a': { + std::memset(g_csendreadyackto, 0, MAX_QUEUE_NAME_SIZE); + std::strncpy(g_csendreadyackto, f_pargumentvalue, (MAX_QUEUE_NAME_SIZE - 1)); + break; + } + case 'v': { + l_iTmpArgValue = atoi(f_pargumentvalue); + CNSNPP::m_siCRCCheckCount = static_cast(l_iTmpArgValue); + break; + } + + default: + l_estatus = eFrameworkunifiedStatusFail; + break; + } + return l_estatus; +} diff --git a/service/native/notification_persistent_service/server/src/ns_npp.cpp b/service/native/notification_persistent_service/server/src/ns_npp.cpp new file mode 100755 index 0000000..25b6443 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp.cpp @@ -0,0 +1,1149 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief +/// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include + +#include +#include "app_states.h" +#include "ns_npp.h" +#include "ns_npp_types.h" +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_threads.h" +#include "ns_npp_copy_worker.h" +#include "ns_npp_fs_directory.h" +#include "ns_npp_persist_folder.h" +#include "ns_npp_persistent_data.h" +#include "ns_npp_persistence_manager.h" +#include "ns_npp_notification_manager.h" +#include "ns_npp_personalization_manager.h" +#include "ns_npp_nor_persistence_worker_thread.h" + +#define NPP_VERSION_INVALID 255 +#define NPP_VERSION_0 0 +#define NPP_VERSION_1 1 + +#define NPP_CONNECT_DEFAULTSTATE(parent, child) \ + FrameworkunifiedConnect(l_p## parent, l_p## child, TRUE); + +#define NPP_CONNECT_STATE(parent, child) \ + FrameworkunifiedConnect(l_p## parent, l_p## child); + +#define NPP_CONNECT_DEFERREDEVENT(state, eventid, reaction) \ + FrameworkunifiedConnect(l_p## state, _## eventid, l_pTrn## reaction, #eventid, TRUE); \ + +#define NPP_CONNECT_EVENT(state, eventid, reaction) \ + FrameworkunifiedConnect(l_p## state, _## eventid, l_pTrn## reaction, #eventid); + +#define NPP_CONNECTROOT(state) \ + FrameworkunifiedConnect(l_p## state); + +#define NPP_CONNECT_ORTHOGONAL_REGION(orthogonalstate, orthogonalregion) \ + FrameworkunifiedConnectOrthogonal(l_p## orthogonalstate, l_p## orthogonalregion); + +#define NPP_CREATE_STATE(class_name) \ + C## class_name *l_p## class_name = new (std::nothrow) C## class_name(#class_name); + +#define NPP_PRINTSTATEMACHINE() \ + FrameworkunifiedPrintAllStates(); + +// typedef of vector of CNotificationsToPersist +typedef std::vector Persistent_Notification_List_Type; + +// iterator for CNotificationsToPersist vector +typedef Persistent_Notification_List_Type::iterator Persistent_Notification_List_Iterator; + +// initialize static variables +SI_32 CNSNPP::m_siWriteThreadPrio = NS_NPP_WRITE_THREAD_PRIO; +SI_32 CNSNPP::m_siReadThreadPrio = NS_NPP_READ_THREAD_PRIO; +SI_32 CNSNPP::m_siImmediatePersistenceThreadPrio = NS_NPP_IMMEDIATE_PERSIST_THREAD_PRIO; +UI_16 CNSNPP::m_siCRCCheckCount = 0; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CNSNPP +/// Class Constructor +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNSNPP::CNSNPP(PVOID f_happ) : CFrameworkunifiedHSM(f_happ), + m_cReadThreadName(NS_NPP_READ_THREAD_NAME), + m_cWriteThreadName(NS_NPP_WRITE_THREAD_NAME), + m_cImmediatePersistenceThreadName(NS_NPP_IMMEDIATE_PERSIST_THREAD_NAME) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + m_hNSReadThread = NULL; + m_hNSWriteThread = NULL; + m_hNSImmediatePersistenceThread = NULL; + + m_pNotificationManager = NULL; + m_pPersonalizationManager = NULL; + m_pPersistenceManager = NULL; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CNSNPP +/// Class Destructor +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNSNPP::~CNSNPP() { // LCOV_EXCL_START 200: cannot test code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != m_pNotificationManager) { + delete m_pNotificationManager; + m_pNotificationManager = NULL; + } + + if (NULL != m_pPersonalizationManager) { + delete m_pPersonalizationManager; + m_pPersonalizationManager = NULL; + } + if (NULL != m_pPersistenceManager) { + delete m_pPersistenceManager; + m_pPersistenceManager = NULL; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// Init +/// This function is used to allocate dynamic memory for member variables of this class after +/// creation of object. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNSNPP::Init(HANDLE f_happ) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + FrameworkunifiedProtocolEvent ns_npp_internal_protocol_handlers[] = { + {CP_WRK_NTFY, EVENT(evNPReleaseLoadAck)} + }; + + FrameworkunifiedProtocolEvent immediate_thread_protocol_handlers[] = { + {NOR_PERSISTENCE_ONSHUTDOWN_ACK, EVENT(evNPNorShutdownAck)}, + }; + + UI_32 l_uiNPPVersion = NPP_VERSION_INVALID; + + // initialize Notification Manager + m_pNotificationManager = new(std::nothrow) CNotificationManager(); + // initialize Personalization Manager + m_pPersonalizationManager = new(std::nothrow) CnotificationpersistentservicePersonalizationManager(); + // initialize Persistence Manager + m_pPersistenceManager = new(std::nothrow) CPersistenceManager(); + + if ((NULL == f_happ) || (NULL == m_pNotificationManager) || (NULL == m_pPersonalizationManager) || (NULL == m_pPersistenceManager)) { // LCOV_EXCL_BR_LINE 5: f_happ, m_pNotificationManager, m_pPersonalizationManager, m_pPersistenceManager can't be NULL // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 5: f_happ, m_pNotificationManager, m_pPersonalizationManager, m_pPersistenceManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "f_happ or m_pNotificationManager or m_pPersonalizationManager or m_pPersistenceManager is NULL"); + + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } else { + if ((eFrameworkunifiedStatusOK != FrameworkunifiedAttachCallbackToDispatcher( // LCOV_EXCL_BR_LINE 4: NSFW error case + f_happ, m_cReadThreadName.c_str(), + CP_WRK_ACK_CMD_COMPLETE, + NPServiceOnCpWorkerAckCmd)) + || (eFrameworkunifiedStatusOK != FrameworkunifiedAttachCallbackToDispatcher( + f_happ, m_cWriteThreadName.c_str(), + CP_WRK_ACK_CMD_COMPLETE, + NPServiceOnCpWorkerAckCmd)) + || (eFrameworkunifiedStatusOK != FrameworkunifiedAttachHSMEventsToDispatcher( + f_happ, m_cWriteThreadName.c_str(), + ns_npp_internal_protocol_handlers, + static_cast(_countof(ns_npp_internal_protocol_handlers)))) + || (eFrameworkunifiedStatusOK != FrameworkunifiedAttachHSMEventsToDispatcher( + f_happ, m_cReadThreadName.c_str(), + ns_npp_internal_protocol_handlers, + static_cast(_countof(ns_npp_internal_protocol_handlers)))) + || (eFrameworkunifiedStatusOK != FrameworkunifiedAttachHSMEventsToDispatcher( + f_happ, m_cImmediatePersistenceThreadName.c_str(), + immediate_thread_protocol_handlers, + static_cast(_countof(immediate_thread_protocol_handlers))))) { + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Attaching callbacks and events failed for protocols CP_WRK_ACK_CMD_COMPLETE, CP_WRK_NTFY"); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } else { + l_estatus = CreateAndStartChildThreads(f_happ); + + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 4: NSFW error case + if (NPP_VERSION_INVALID != (l_uiNPPVersion = GetNSNPPVersion())) { // LCOV_EXCL_BR_LINE 6: l_uiNPPVersion can't be NPP_VERSION_INVALID // NOLINT[whitespace/line_length] + if (NPP_VERSION_0 == l_uiNPPVersion) { + l_estatus = SwitchToFileStructureVersion1(l_uiNPPVersion + 1); + + l_estatus = SwitchToFileStructureVersion2(l_uiNPPVersion + 2); + } else if (NPP_VERSION_1 == l_uiNPPVersion) { // LCOV_EXCL_BR_LINE 200: cannot test code in init sequence + // LCOV_EXCL_START 200: cannot test code in init sequence + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = SwitchToFileStructureVersion2(l_uiNPPVersion + 1); + + // send the message to write worker thread to delete the persistent + /// which was requested for deletion during previous shutdown + l_estatus = FrameworkunifiedSendChild(f_happ, m_hNSWriteThread, CMD_DELETE_OLD_DATA, 0, NULL); + // LCOV_EXCL_STOP + } else { + // send the message to write worker thread to delete the persistent + /// which was requested for deletion during previous shutdown + l_estatus = FrameworkunifiedSendChild(f_happ, m_hNSWriteThread, CMD_DELETE_OLD_DATA, 0, NULL); + } + + // Try to load persisted notification data + NotificationpersistentserviceLoadPersistentNotificationData(eFrameworkunifiedPersistedStateVar); + + // load immediate persistence data as the respective thread is now started. + NotificationpersistentserviceLoadPersistentNotificationData(eFrameworkunifiedImmediatePersistedStateVar); + } else { + // LCOV_EXCL_START 6: l_uiNPPVersion can't be NPP_VERSION_INVALID + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid version of NPPService"); + // LCOV_EXCL_STOP + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in creating child threads of NPPService"); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// DeInit +/// This function is used to deinitialize the NPP object +//////////////////////////////////////////////////////////////////////////////////////////////////// +VOID CNSNPP::DeInit(HANDLE f_happ) { // LCOV_EXCL_START 200: cannot test code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != m_pNotificationManager) { + delete m_pNotificationManager; + m_pNotificationManager = NULL; + } + + if (NULL != m_pPersonalizationManager) { + delete m_pPersonalizationManager; + m_pPersonalizationManager = NULL; + } + + if (NULL != m_pPersistenceManager) { + delete m_pPersistenceManager; + m_pPersistenceManager = NULL; + } + + if (NULL != f_happ) { + EFrameworkunifiedStatus eStatus; + + if (NULL != m_hNSReadThread) { + if (eFrameworkunifiedStatusOK != (eStatus = FrameworkunifiedStopChildThread(f_happ, m_hNSReadThread, 0, NULL))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedStopChildThread Read Thread Failed. status=%d", eStatus); + } + if (eFrameworkunifiedStatusOK != (eStatus = FrameworkunifiedDestroyChildThread(f_happ, m_hNSReadThread))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedDestroyChildThread Read Thread Failed. status=%d", eStatus); + } + m_hNSReadThread = NULL; + } + + if (NULL != m_hNSWriteThread) { + if (eFrameworkunifiedStatusOK != (eStatus = FrameworkunifiedStopChildThread(f_happ, m_hNSWriteThread, 0, NULL))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedStopChildThread Write Thread Failed. status=%d", eStatus); + } + if (eFrameworkunifiedStatusOK != (eStatus = FrameworkunifiedDestroyChildThread(f_happ, m_hNSWriteThread))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedDestroyChildThread Write Thread Failed. status=%d", eStatus); + } + m_hNSWriteThread = NULL; + } + + if (NULL != m_hNSImmediatePersistenceThread) { + if (eFrameworkunifiedStatusOK != (eStatus = FrameworkunifiedStopChildThread(f_happ, m_hNSImmediatePersistenceThread, 0, NULL))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedStopChildThread ImmidatePersistence Thread Failed. status=%d", eStatus); + } + if (eFrameworkunifiedStatusOK != (eStatus = FrameworkunifiedDestroyChildThread(f_happ, m_hNSImmediatePersistenceThread))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedDestroyChildThread ImmidatePersistence Thread Failed. status=%d", eStatus); + } + m_hNSImmediatePersistenceThread = NULL; + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// SwitchToFileStructureVersion1 +/// Copy all the user data from old persistent path to new persistent path i.e. UserData folder +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNSNPP::SwitchToFileStructureVersion1(const UI_32 f_uinppversion) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + std::string l_cSrcPath = ""; + std::string l_cDestPath = ""; + + std::string l_cNSNPSPath = CPersistence::GetStoragePath(); + std::string l_cUserDataPath = ""; + + if (CFSDirectory::DoesDirecotryExist(l_cNSNPSPath)) { // LCOV_EXCL_BR_LINE 6: l_cNSNPSPath must exist + DIR *l_pdir = NULL; + + struct dirent *l_pdirent = NULL; + + l_pdir = opendir(l_cNSNPSPath.c_str()); + + if (NULL != l_pdir) { // LCOV_EXCL_BR_LINE 4: NSFW error case + if (l_cNSNPSPath[l_cNSNPSPath.length() - 1] != '/') { // LCOV_EXCL_BR_LINE 6: l_cNSNPSPath must has '/' + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_cNSNPSPath.append("/"); // LCOV_EXCL_LINE 6: l_cNSNPSPath must has '/' + } + + // set the userdata folder path + l_cUserDataPath.assign(l_cNSNPSPath); + l_cUserDataPath.append(USERDATADIR); + l_cUserDataPath.append(ALLUSERAPPDATADIR); + + // create the userdata directory + if (!CFSDirectory::DoesDirecotryExist(l_cUserDataPath)) { + l_estatus = CFSDirectory::CreateDirectory(l_cUserDataPath); + } + + // if directory successfully created or is already present on target + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 6: l_estatus must be eFrameworkunifiedStatusOK + while (NULL != (l_pdirent = readdir(l_pdir))) { + if (0 != std::strcmp(l_pdirent->d_name, ".") && + 0 != std::strcmp(l_pdirent->d_name, "..") && + 0 != std::strcmp(l_pdirent->d_name, AppName) && + 0 != std::strcmp(l_pdirent->d_name, USERDATA)) { + l_cSrcPath.assign(l_cNSNPSPath.c_str()); + l_cSrcPath.append(l_pdirent->d_name); + + if (CFSDirectory::IsDirectory(l_cSrcPath)) { // LCOV_EXCL_BR_LINE 6: cannot test in init sequence + l_cDestPath.assign(l_cUserDataPath); + l_cDestPath.append(l_pdirent->d_name); + + // move the old app user data to the UserData fodler + if (0 != rename(l_cSrcPath.c_str(), l_cDestPath.c_str())) { // LCOV_EXCL_BR_LINE 6: rename must return ok // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: rename must return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error renaming folder %s to %s", + l_cSrcPath.c_str(), l_cDestPath.c_str()); + // LCOV_EXCL_STOP + } + } + } + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to create directory:: %s", l_cDestPath.c_str()); // LCOV_EXCL_LINE 6: l_estatus must be eFrameworkunifiedStatusOK // NOLINT[whitespace/line_length] + } + + closedir(l_pdir); // close the directory + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pdir is NULL"); + // LCOV_EXCL_STOP + } + } + + l_estatus = SetNSNPPVersion(static_cast(f_uinppversion)); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// SwitchToFileStructureVersion2 +/// Move immediate notification data files from IMMEDIATE_PERSISTENCE_STORAGE_V1 to +/// IMMEDIATE_PERSISTENCE_STORAGE_V2/AllUserAppData/UserData +//// //////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNSNPP::SwitchToFileStructureVersion2(const UI_32 f_uinppversion) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // immediate notification persistent path for NPPService version 1 + std::string l_cSrcDir = IMMEDIATE_PERSISTENCE_STORAGE_V1; + + // immediate notification persistent path for NPPService version 2 + std::string l_cDestDir = IMMEDIATE_PERSISTENCE_STORAGE_V2; + l_cDestDir.append(USERDATADIR); + l_cDestDir.append(ALLUSERAPPDATADIR); + l_cDestDir.append(IMMEDIATEDATADIR); + + if (eFrameworkunifiedStatusOK == (l_estatus = SynchronousMovePersistentData(l_cSrcDir.c_str(), l_cDestDir.c_str()))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + if (!CFSDirectory::RemoveDirectory(l_cSrcDir)) { // LCOV_EXCL_BR_LINE 6: cannot test in init sequence + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Error deleting old immediate pers. dir %s", l_cSrcDir.c_str()); + } + + l_estatus = SetNSNPPVersion(static_cast(f_uinppversion)); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "SynchronousMovePersistentData faiure, status=%d", l_estatus); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +/////////////////////////////////////////////////////////////////////////////////////////// +/// GetNSNPPVersion +/// Get the version of NSNPP from version.txt +/////////////////////////////////////////////////////////////////////////////////////////// +UI_32 CNSNPP::GetNSNPPVersion() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + UI_32 l_uiVersion = NPP_VERSION_INVALID; + CHAR l_cVerStr[3] = {}; + FILE *l_pFile = NULL; + + std::string l_cVersion = CPersistence::GetStoragePath(); + if (l_cVersion[l_cVersion.length() - 1] != '/') { // LCOV_EXCL_BR_LINE 6: must has '/' + l_cVersion += "/"; + } + l_cVersion.append(VERSION_TXT); + + if (NULL != (l_pFile = fopen(l_cVersion.c_str(), "r"))) { + // read the version from file + if (NULL == fgets(l_cVerStr, 2, l_pFile)) { // LCOV_EXCL_BR_LINE 6: can't return NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "File empty: %s", l_cVersion.c_str()); // LCOV_EXCL_LINE 6: can't return NULL + } else { + errno = EOK; + l_uiVersion = static_cast(strtol(l_cVerStr, NULL, 10)); + + if (EOK != errno) { // LCOV_EXCL_BR_LINE 6: errno always is EOK + // LCOV_EXCL_START 6: errno always is EOK + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Error converting string %s to hex, errno=%d", l_cVerStr, errno); + l_uiVersion = NPP_VERSION_0; + // LCOV_EXCL_STOP + } + } + + fclose(l_pFile); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to open file: %s, errno=%d", l_cVersion.c_str(), errno); + l_uiVersion = NPP_VERSION_0; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_uiVersion; +} +/////////////////////////////////////////////////////////////////////////////////////////// +/// Syncfs +/// Syncfs is carried out. +/// +/// \param +/// +/// \return EFrameworkunifiedStatus +/// EFrameworkunifiedStatus - Returns status of operation +/// +/////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNSNPP::Syncfs() { + int dfd; + + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + std::string l_cPath = CPersistence::GetStoragePath(); + + // create the file + dfd = open(l_cPath.c_str(), O_RDONLY | O_DIRECTORY); + if (-1 != dfd) { + // syncfs() + if (syncfs(dfd) < 0) { // LCOV_EXCL_BR_LINE 5: syncfs's error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to syncfs: %s errno=%d", l_cPath.c_str(), errno); // LCOV_EXCL_LINE 5: syncfs's error case. // NOLINT[whitespace/line_length] + } + close(dfd); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to open file: %s serrno=%d", l_cPath.c_str(), errno); + l_estatus = eFrameworkunifiedStatusNullPointer; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} +/////////////////////////////////////////////////////////////////////////////////////////// +/// SetNSNPPVersion +/// Set the version of NSNPP in version.txt +/////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNSNPP::SetNSNPPVersion(UI_8 f_uiversion) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + FILE *l_pFile = NULL; + + std::string l_cVersion = CPersistence::GetStoragePath(); + if (l_cVersion[l_cVersion.length() - 1] != '/') { // LCOV_EXCL_BR_LINE 6: must has '/' + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_cVersion += "/"; // LCOV_EXCL_LINE 6: must has '/' + } + if (!CFSDirectory::DoesDirecotryExist(l_cVersion)) { + CFSDirectory::CreateDirectory(l_cVersion); + } + + l_cVersion.append(VERSION_TXT); + + // create the file and write + l_pFile = fopen(l_cVersion.c_str(), "w"); + if (NULL != l_pFile) { // LCOV_EXCL_BR_LINE 6: l_pFile can't be NULL + // write the version to file + fprintf(l_pFile, "%d", f_uiversion); + fclose(l_pFile); + } else { + // LCOV_EXCL_START 6: l_pFile can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to open file: %s", l_cVersion.c_str()); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// FrameworkunifiedCreate +/// In this function, states and events of StateMachine are created and connected. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNSNPP::FrameworkunifiedCreate(PVOID f_peventdata) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // ========Create states + NPP_CREATE_STATE(sNotificationpersistentserviceNPPRoot) + NPP_CREATE_STATE(sNotificationpersistentserviceNPPStart) + NPP_CREATE_STATE(sNotificationpersistentserviceNPPError) + + CREATE_ORTHOGONALREGION(sNotificationpersistentservicePersistence) + CREATE_ORTHOGONALREGION(sNotificationpersistentserviceShutdown) + CREATE_ORTHOGONALREGION(sNotificationpersistentserviceNotification) + + NPP_CREATE_STATE(sNotificationpersistentservicePersistenceReady) + NPP_CREATE_STATE(sNotificationpersistentservicePersistenceError) + + NPP_CREATE_STATE(sNotificationpersistentserviceNotificationReady) + NPP_CREATE_STATE(sNotificationpersistentserviceNotificationError) + + NPP_CREATE_STATE(sNotificationpersistentserviceShutdownIdle) + NPP_CREATE_STATE(sNotificationpersistentserviceShutdownDataSave) + + // ========Connect states + NPP_CONNECT_DEFAULTSTATE(sNotificationpersistentserviceNPPRoot, sNotificationpersistentserviceNPPStart) + NPP_CONNECT_STATE(sNotificationpersistentserviceNPPRoot, sNotificationpersistentserviceNPPStart) + NPP_CONNECT_STATE(sNotificationpersistentserviceNPPRoot, sNotificationpersistentserviceNPPError) + + NPP_CONNECT_ORTHOGONAL_REGION(sNotificationpersistentserviceNPPStart, sNotificationpersistentservicePersistence) + NPP_CONNECT_ORTHOGONAL_REGION(sNotificationpersistentserviceNPPStart, sNotificationpersistentserviceShutdown) + NPP_CONNECT_ORTHOGONAL_REGION(sNotificationpersistentserviceNPPStart, sNotificationpersistentserviceNotification) + + NPP_CONNECT_DEFAULTSTATE(sNotificationpersistentservicePersistence, sNotificationpersistentservicePersistenceReady) + NPP_CONNECT_STATE(sNotificationpersistentservicePersistence, sNotificationpersistentservicePersistenceError) + + NPP_CONNECT_DEFAULTSTATE(sNotificationpersistentserviceShutdown, sNotificationpersistentserviceShutdownIdle) + NPP_CONNECT_STATE(sNotificationpersistentserviceShutdown, sNotificationpersistentserviceShutdownDataSave) + + NPP_CONNECT_DEFAULTSTATE(sNotificationpersistentserviceNotification, sNotificationpersistentserviceNotificationReady) + NPP_CONNECT_STATE(sNotificationpersistentserviceNotification, sNotificationpersistentserviceNotificationError) + + // ========Create external transitions + CREATE_EXTERNALTRANSITION(sNotificationpersistentserviceNPPStart) + CREATE_EXTERNALTRANSITION(sNotificationpersistentserviceNPPError) + CREATE_EXTERNALTRANSITION(sNotificationpersistentservicePersistenceReady) + CREATE_EXTERNALTRANSITION(sNotificationpersistentservicePersistenceError) + CREATE_EXTERNALTRANSITION(sNotificationpersistentserviceShutdownIdle) + CREATE_EXTERNALTRANSITION(sNotificationpersistentserviceShutdownDataSave) + CREATE_EXTERNALTRANSITION(sNotificationpersistentserviceNotificationReady) + CREATE_EXTERNALTRANSITION(sNotificationpersistentserviceNotificationError) + + // ========Create internal transitions + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPReadPersistedData) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPReleaseFileAck) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnUserChange) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPNorDataSaveAck) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnRegisterPersistentFile) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnReleasePersistentFile) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnLoadPersistentFile) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnRegisterPersistentFolder) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnLoadPersistentFolder) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnReleasePersistentFolder) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPSetFilePersistentType) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPSetFolderPersistentType) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPPersistentSync) + + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPShutdown) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnShutdownTimeout) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceCheckAllReleaseRequestsProcessed) + + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPPublishNotification) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPRegisterNotifications) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPSubscribeToNotification) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPSubscribeToNotifications) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPUnRegisterNotifications) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPUnSubscribeFromNotification) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPUnSubscribeFromNotifications) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPGetReadyStatus) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPRegisterImmediateNotifications) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPClearPersistedData) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPSetDefaultPersistentData) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPSetNotfnPersistentType) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPPublishImmediateNotification) + +#ifdef NPP_PROFILEINFO_ENABLE + + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPProfileNotifications) + CREATE_INTERNALTRANSITION(NotificationpersistentserviceOnNPProfilePersistence) + + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationReady, evNPProfileNotification, NotificationpersistentserviceOnNPProfileNotifications) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evNPProfilePersistence, NotificationpersistentserviceOnNPProfilePersistence) + +#endif + + // ========Connect events + NPP_CONNECT_EVENT(sNotificationpersistentserviceNPPRoot, evNPClearPersistedData, NotificationpersistentserviceOnNPClearPersistedData) + + NPP_CONNECT_EVENT(sNotificationpersistentserviceNPPStart, evError, sNotificationpersistentserviceNPPError) + NPP_CONNECT_EVENT(sNotificationpersistentserviceNPPError, evReady, sNotificationpersistentserviceNPPStart) + + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evError, sNotificationpersistentservicePersistenceError) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceError, evReady, sNotificationpersistentservicePersistenceReady) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evNPReadPersistedData, NotificationpersistentserviceOnNPReadPersistedData) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evNPReleaseLoadAck, NotificationpersistentserviceOnNPReleaseFileAck) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evNPRegisterPersistentFile, NotificationpersistentserviceOnRegisterPersistentFile) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evNPReleasePersistentFile, NotificationpersistentserviceOnReleasePersistentFile) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evNPLoadPersistentFile, NotificationpersistentserviceOnLoadPersistentFile) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evNPRegisterPersistentFolder, NotificationpersistentserviceOnRegisterPersistentFolder) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evNPLoadPersistentFolder, NotificationpersistentserviceOnLoadPersistentFolder) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evNPReleasePersistentFolder, NotificationpersistentserviceOnReleasePersistentFolder) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evNPGetReadyStatus, NotificationpersistentserviceOnNPGetReadyStatus) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evNPSetFilePersistentType, NotificationpersistentserviceOnNPSetFilePersistentType) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evNPSetFolderPersistentType, NotificationpersistentserviceOnNPSetFolderPersistentType) + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evNPPersistentSync, NotificationpersistentserviceOnNPPersistentSync) + + NPP_CONNECT_EVENT(sNotificationpersistentservicePersistenceReady, evUserChange, NotificationpersistentserviceOnUserChange) + + NPP_CONNECT_EVENT(sNotificationpersistentserviceShutdownIdle, evShutdown, NotificationpersistentserviceOnNPShutdown) + NPP_CONNECT_EVENT(sNotificationpersistentserviceShutdownIdle, evNPShutdownDataSave, sNotificationpersistentserviceShutdownDataSave) + NPP_CONNECT_EVENT(sNotificationpersistentserviceShutdownDataSave, evIdle, sNotificationpersistentserviceShutdownIdle) + NPP_CONNECT_EVENT(sNotificationpersistentserviceShutdownDataSave, evShutdownTimeout, NotificationpersistentserviceOnShutdownTimeout) + NPP_CONNECT_EVENT(sNotificationpersistentserviceShutdownDataSave, evCheckAllFilesPersisted, NotificationpersistentserviceCheckAllReleaseRequestsProcessed) + NPP_CONNECT_EVENT(sNotificationpersistentserviceShutdownDataSave, evNPNorShutdownAck, NotificationpersistentserviceOnNPNorDataSaveAck) + + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationReady, evError, sNotificationpersistentserviceNotificationError) + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationError, evReady, sNotificationpersistentserviceNotificationReady) + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationReady, evNPPublishNotification, NotificationpersistentserviceOnNPPublishNotification) + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationReady, evNPRegisterNotifications, NotificationpersistentserviceOnNPRegisterNotifications) + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationReady, evNPSubscribeToNotification, NotificationpersistentserviceOnNPSubscribeToNotification) + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationReady, evNPSubscribeToNotifications, NotificationpersistentserviceOnNPSubscribeToNotifications) + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationReady, evNPUnRegisterNotifications, NotificationpersistentserviceOnNPUnRegisterNotifications) + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationReady, evNPUnSubscribeFromNotification, NotificationpersistentserviceOnNPUnSubscribeFromNotification) + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationReady, evNPUnSubscribeFromNotifications, NotificationpersistentserviceOnNPUnSubscribeFromNotifications) + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationReady, evNPRegisterImmediateNotifications, NotificationpersistentserviceOnNPRegisterImmediateNotifications) + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationReady, evNPSetDefaultPersistentData, NotificationpersistentserviceOnNPSetDefaultPersistentData) + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationReady, evNPSetNotfnPersistentType, NotificationpersistentserviceOnNPSetNotfnPersistentType) + NPP_CONNECT_EVENT(sNotificationpersistentserviceNotificationReady, evNPPublishImmediateNotification, NotificationpersistentserviceOnNPPublishImmediateNotification) + + NPP_CONNECTROOT(sNotificationpersistentserviceNPPRoot) + + NPP_PRINTSTATEMACHINE() // NOLINT (whitespace/empty_if_body) + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentservicePersistAll +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNSNPP::NotificationpersistentservicePersistAll(EFrameworkunifiedShutdownType f_eshutdowntype, UI_32 f_uinotificationpersistentservicepersistcategoryflag) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (eFrameworkunifiedQuickShutdown == f_eshutdowntype) { + if (NULL != m_pPersistenceManager) { // LCOV_EXCL_BR_LINE 6: m_pPersistenceManager can't be NULL + // set all file persisted status as TRUE + m_pPersistenceManager->SetFilePersistedStatus(TRUE); + + // send request to immediate persistence thread to stop all the immediate notification timer + m_pPersistenceManager->PersistNORData(f_eshutdowntype, f_uinotificationpersistentservicepersistcategoryflag); + } + } else { + if (eFrameworkunifiedNormalShutdown == f_eshutdowntype) { + f_uinotificationpersistentservicepersistcategoryflag = 0x0; + } + + // save global notification data of persisted state notification + if (eFrameworkunifiedStatusOK != NotificationpersistentserviceSaveNotificationPersistentData(eFrameworkunifiedPersistedStateVar, f_uinotificationpersistentservicepersistcategoryflag)) { // LCOV_EXCL_BR_LINE 6: NotificationpersistentserviceSaveNotificationPersistentData will always return ok // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: NotificationpersistentserviceSaveNotificationPersistentData will always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error while saving notification persistent data."); + // LCOV_EXCL_STOP + } + + // save user notification data for the current user + if (eFrameworkunifiedStatusOK != NotificationpersistentserviceSaveNotificationPersistentData(eFrameworkunifiedPersistedStateUserVar, f_uinotificationpersistentservicepersistcategoryflag)) { // LCOV_EXCL_BR_LINE 6: NotificationpersistentserviceSaveNotificationPersistentData will always return ok // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: NotificationpersistentserviceSaveNotificationPersistentData will always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error while saving user notification persistent data."); + // LCOV_EXCL_STOP + } + + // NOR data is saved immediately, + // but during shutdown it can be possible that because of delay in consecutive save to NOR + // the latest data may not get persisted. So if we get shutdown we will need to persist the data immediately. + if (NULL != m_pPersistenceManager) { // LCOV_EXCL_BR_LINE 6: m_pPersistenceManager can't be NULL + m_pPersistenceManager->PersistNORData(f_eshutdowntype, f_uinotificationpersistentservicepersistcategoryflag); + } + + // delete all persistent files and folders for all applications + if ((eFrameworkunifiedUserData | eFrameworkunifiedFactoryData | eFrameworkunifiedFactoryCustomerData | eFrameworkunifiedDealerData) == f_uinotificationpersistentservicepersistcategoryflag) { + if (NULL != m_pPersistenceManager) { // LCOV_EXCL_BR_LINE 6: m_pPersistenceManager can't be NULL + m_pPersistenceManager->SetFilePersistedStatus(TRUE); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; // LCOV_EXCL_LINE 6: m_pPersistenceManager can't be NULL + } + } else { + // writes the temporary global and user files to permanent memory + if (m_pPersistenceManager) { // LCOV_EXCL_BR_LINE 6: m_pPersistenceManager can't be NULL + if (eFrameworkunifiedStatusOK == m_pPersistenceManager->PersistAllReleaseRequests(f_uinotificationpersistentservicepersistcategoryflag)) { // LCOV_EXCL_BR_LINE 6: PersistAllReleaseRequests will always return ok // NOLINT[whitespace/line_length] + // this is needed to check in case when there are no file to persist + if (TRUE == m_pPersistenceManager->HaveAllReleaseRequestsPersisted()) { // LCOV_EXCL_BR_LINE 6: HaveAllReleaseRequestsPersisted will always return ok // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: HaveAllReleaseRequestsPersisted will always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "All file release requests processed"); + m_pPersistenceManager->SetFilePersistedStatus(TRUE); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: PersistAllReleaseRequests will always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error while persisting temporary files."); + // LCOV_EXCL_STOP + } + } + } + } + + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// DeletePersistedDataFolder +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNSNPP::DeletePersistedDataFolder(UI_32 f_uinotificationpersistentservicepersistcategoryflag) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + struct timeb timebuf; + struct tm *theTime; + + ftime(&timebuf); + theTime = gmtime(&timebuf.time); // NOLINT (runtime/threadsafe_fn) + + // get the current date and time to append to the folder name + PCHAR l_cDateTime = new CHAR[MAX_STRING_SIZE_TAG]; + snprintf(l_cDateTime, MAX_STRING_SIZE_TAG, "_%02d%02d%02d_%02d%02d%02d", theTime->tm_mon + 1, theTime->tm_mday, + theTime->tm_year + 1900, theTime->tm_hour, theTime->tm_min, theTime->tm_sec); + + std::string l_cBasePath = CPersistence::GetStoragePath(); + std::string l_cSrcPath = ""; + std::string l_cDestPath = ""; + + if (eFrameworkunifiedUserData == (eFrameworkunifiedUserData & f_uinotificationpersistentservicepersistcategoryflag)) { + l_cSrcPath.assign(l_cBasePath); + l_cSrcPath.append(USERDATA); + + if (CFSDirectory::DoesDirecotryExist(l_cSrcPath)) { + l_cDestPath.assign(l_cSrcPath); + l_cDestPath.append(l_cDateTime); + + // instead of deleting the data, rename the persistence folder before shutdown + if (0 != rename(l_cSrcPath.c_str(), l_cDestPath.c_str())) { // LCOV_EXCL_BR_LINE 6: rename must return ok + // LCOV_EXCL_START 6: rename must return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error renaming folder %s to %s, errno = %d", + l_cSrcPath.c_str(), + l_cDestPath.c_str(), + errno); + // LCOV_EXCL_STOP + } + } + } + if (eFrameworkunifiedFactoryData == (eFrameworkunifiedFactoryData & f_uinotificationpersistentservicepersistcategoryflag)) { + l_cSrcPath.assign(l_cBasePath); + l_cSrcPath.append(FACTORYDATA); + + if (CFSDirectory::DoesDirecotryExist(l_cSrcPath)) { + l_cDestPath.assign(l_cSrcPath); + l_cDestPath.append(l_cDateTime); + + // instead of deleting the data, rename the persistence folder before shutdown + if (0 != rename(l_cSrcPath.c_str(), l_cDestPath.c_str())) { // LCOV_EXCL_BR_LINE 6: rename must return ok + // LCOV_EXCL_START 6: rename must return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error renaming folder %s to %s, errno = %d", + l_cSrcPath.c_str(), + l_cDestPath.c_str(), + errno); + // LCOV_EXCL_STOP + } + } + } + if (eFrameworkunifiedFactoryCustomerData == (eFrameworkunifiedFactoryCustomerData & f_uinotificationpersistentservicepersistcategoryflag)) { + l_cSrcPath.assign(l_cBasePath); + l_cSrcPath.append(FACTORYCUSTOMERDATA); + + if (CFSDirectory::DoesDirecotryExist(l_cSrcPath)) { + l_cDestPath.assign(l_cSrcPath); + l_cDestPath.append(l_cDateTime); + + // instead of deleting the data, rename the persistence folder before shutdown + if (0 != rename(l_cSrcPath.c_str(), l_cDestPath.c_str())) { // LCOV_EXCL_BR_LINE 6: rename must return ok + // LCOV_EXCL_START 6: rename must return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error renaming folder %s to %s, errno = %d", + l_cSrcPath.c_str(), + l_cDestPath.c_str(), + errno); + // LCOV_EXCL_STOP + } + } + } + if (eFrameworkunifiedDealerData == (eFrameworkunifiedDealerData & f_uinotificationpersistentservicepersistcategoryflag)) { + l_cSrcPath.assign(l_cBasePath); + l_cSrcPath.append(DEALERDATA); + + if (CFSDirectory::DoesDirecotryExist(l_cSrcPath)) { + l_cDestPath.assign(l_cSrcPath); + l_cDestPath.append(l_cDateTime); + + // instead of deleting the data, rename the persistence folder before shutdown + if (0 != rename(l_cSrcPath.c_str(), l_cDestPath.c_str())) { // LCOV_EXCL_BR_LINE 6: rename must return ok + // LCOV_EXCL_START 6: rename must return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error renaming folder %s to %s, errno = %d", + l_cSrcPath.c_str(), + l_cDestPath.c_str(), + errno); + // LCOV_EXCL_STOP + } + } + } + + if (NULL != l_cDateTime) { // LCOV_EXCL_BR_LINE 6: l_cDateTime can't be NULL + delete[] l_cDateTime; + l_cDateTime = NULL; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceSaveNotificationPersistentData +/// In this function, all the data related to persistent notification is retrieved from +/// notification manager and stored in persistent file by persistent manager. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNSNPP::NotificationpersistentserviceSaveNotificationPersistentData(EFrameworkunifiedNotificationType f_epersistenttype, + UI_32 f_uinotificationpersistentservicepersistcategoryflag) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + // pointer of Notification Manager + CNotificationManager *l_pNotificationManager = NULL; + + // pointer of Persistence Manager + CPersistenceManager *l_pCNotificationpersistentservicePersistenceManager = NULL; + + Persistent_Notification_List_Type *l_vPersistentNotificationList = NULL; + + // get the instance of notification manager + l_pNotificationManager = m_pNotificationManager; + + // get the instance of persistence manager + l_pCNotificationpersistentservicePersistenceManager = m_pPersistenceManager; + + if (NULL != l_pNotificationManager && NULL != l_pCNotificationpersistentservicePersistenceManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager and l_pCNotificationpersistentservicePersistenceManager can't be NULL // NOLINT[whitespace/line_length] + // create new vector to retrieve persistent notification data + l_vPersistentNotificationList = new(std::nothrow) Persistent_Notification_List_Type(); + + if (NULL != l_vPersistentNotificationList) { // LCOV_EXCL_BR_LINE 5: l_vPersistentNotificationList can't be NULL + // get all the persistent notification data in vector from notification manager + l_pNotificationManager->NotificationpersistentserviceGetPersistentNotificationData(l_vPersistentNotificationList, + f_epersistenttype, + f_uinotificationpersistentservicepersistcategoryflag); + } else { + // LCOV_EXCL_START 5: l_vPersistentNotificationList can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_vPersistentNotificationList is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + + if (NULL != l_vPersistentNotificationList) { // LCOV_EXCL_BR_LINE 5: l_vPersistentNotificationList can't be NULL + if (eFrameworkunifiedPersistedStateVar == f_epersistenttype) { + // save persistent notification data from vector to file + l_estatus = l_pCNotificationpersistentservicePersistenceManager->NotificationpersistentserviceSaveNotificationData(l_vPersistentNotificationList); + } else if (eFrameworkunifiedPersistedStateUserVar == f_epersistenttype) { // LCOV_EXCL_BR_LINE 200: f_epersistenttype must be eFrameworkunifiedPersistedStateVar or eFrameworkunifiedPersistedStateUserVar // NOLINT[whitespace/line_length] + l_estatus = l_pCNotificationpersistentservicePersistenceManager->NotificationpersistentserviceSaveUserNotificationData(l_vPersistentNotificationList); + } else { + // LCOV_EXCL_START 200: f_epersistenttype must be eFrameworkunifiedPersistedStateVar or eFrameworkunifiedPersistedStateUserVar + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Save data for %d PersistentVarType not supported", f_epersistenttype); + // LCOV_EXCL_STOP + } + + + // delete the locally created vector + if (!l_vPersistentNotificationList->empty()) { + for (UI_32 l_uiCount = 0; + l_uiCount < l_vPersistentNotificationList->size(); + l_uiCount++) { + if (NULL != l_vPersistentNotificationList->at(l_uiCount)) { // LCOV_EXCL_BR_LINE 6: can't be NULL + delete l_vPersistentNotificationList->at(l_uiCount); + } + } + + // clear the vector + l_vPersistentNotificationList->clear(); + } + + delete l_vPersistentNotificationList; + l_vPersistentNotificationList = NULL; + } else { + // LCOV_EXCL_START 5: l_vPersistentNotificationList can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_vPersistentNotificationList is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: l_pNotificationManager and l_pCNotificationpersistentservicePersistenceManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pNotificationManager is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceOnLoadPersistentData +/// In this transition, persistent file is loaded by persistent manager and +/// persistent notifications and its data is stored by notification manager. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNSNPP::NotificationpersistentserviceLoadPersistentNotificationData(EFrameworkunifiedNotificationType f_epersistenttype) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + // pointer of Notification Manager + CNotificationManager *l_pNotificationManager = NULL; + + // pointer of Persistence Manager + CPersistenceManager *l_pNotificationpersistentservicePersistenceManager = NULL; + + // iterator of CNotificationToPersist vector + Persistent_Notification_List_Type *l_vPersistentNotificationList = NULL; + + // get the instance of notification manager + l_pNotificationManager = m_pNotificationManager; + + // get the instance of persistent manager + l_pNotificationpersistentservicePersistenceManager = m_pPersistenceManager; + + // create new vector for persistent notifications + l_vPersistentNotificationList = new(std::nothrow) Persistent_Notification_List_Type(); + + if (NULL != l_vPersistentNotificationList) { // LCOV_EXCL_BR_LINE 5: l_vPersistentNotificationList can't be NULL + if (NULL != l_pNotificationManager && NULL != l_pNotificationpersistentservicePersistenceManager) { // LCOV_EXCL_BR_LINE 6: l_pNotificationManager and l_pNotificationpersistentservicePersistenceManager can't be NULL // NOLINT[whitespace/line_length] + if (eFrameworkunifiedPersistedStateVar == f_epersistenttype) { + // read persistent notification data from file and store in vector + l_estatus = l_pNotificationpersistentservicePersistenceManager->NotificationpersistentserviceReadNotificationData(l_vPersistentNotificationList); + } else if (eFrameworkunifiedPersistedStateUserVar == f_epersistenttype) { + l_estatus = l_pNotificationpersistentservicePersistenceManager->NotificationpersistentserviceReadUserNotificationData(l_vPersistentNotificationList); + } else if (eFrameworkunifiedImmediatePersistedStateVar == f_epersistenttype) { // LCOV_EXCL_BR_LINE 200: f_epersistenttype must be eFrameworkunifiedPersistedStateVar or eFrameworkunifiedPersistedStateUserVar or eFrameworkunifiedImmediatePersistedStateVar // NOLINT[whitespace/line_length] + l_estatus = l_pNotificationpersistentservicePersistenceManager->NotificationpersistentserviceReadNorNotificationData(l_vPersistentNotificationList); + } else { + // LCOV_EXCL_START 200: f_epersistenttype must be eFrameworkunifiedPersistedStateVar or eFrameworkunifiedPersistedStateUserVar or eFrameworkunifiedImmediatePersistedStateVar // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Read data for %d PersistentVarType not supported", f_epersistenttype); + // LCOV_EXCL_STOP + } + + if (0 < l_vPersistentNotificationList->size()) { + // send the notification list to notification manager + l_estatus = l_pNotificationManager->NotificationpersistentserviceSetPersistentNotificationData(l_vPersistentNotificationList); + } + } else { + // LCOV_EXCL_START 6: l_pNotificationManager and l_pNotificationpersistentservicePersistenceManager can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pNotificationManager or l_pNotificationpersistentservicePersistenceManager is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + + if (!l_vPersistentNotificationList->empty()) { + for (UI_32 l_uiCount = 0; + l_uiCount < l_vPersistentNotificationList->size(); + l_uiCount++) { + if (NULL != l_vPersistentNotificationList->at(l_uiCount)) { // LCOV_EXCL_BR_LINE 6: can't be NULL + delete l_vPersistentNotificationList->at(l_uiCount); + } + } + + // clear the vector + l_vPersistentNotificationList->clear(); + } + + delete l_vPersistentNotificationList; + l_vPersistentNotificationList = NULL; + } else { + // LCOV_EXCL_START 5: l_vPersistentNotificationList can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Memory allocation error for l_vPersistentNotificationList"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CreateAndStartChildThreads +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNSNPP::CreateAndStartChildThreads(HANDLE f_happ) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (NULL == f_happ) { // LCOV_EXCL_BR_LINE 6: f_happ can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; // LCOV_EXCL_LINE 6: f_happ can't be NULL + } + + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 6: l_estatus is eFrameworkunifiedStatusOK + // create reader thread + if (NULL != (m_hNSReadThread = FrameworkunifiedCreateChildThreadWithPriority(f_happ, m_cReadThreadName.c_str(), NSPCopyWorkerOnStart, NSPCopyWorkerOnStop, CNSNPP::m_siReadThreadPrio))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + "Thread %s created, Prio=%d", + m_cReadThreadName.c_str(), + CNSNPP::m_siReadThreadPrio); + + // start the reader thread + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedStartChildThread(f_happ, m_hNSReadThread, 0, NULL))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + m_pPersistenceManager->SetReadThreadHandle(m_hNSReadThread); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Fail to Start Read Worker thread. Status:0x%x", l_estatus); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error creating NPP Read Worker thread"); + // LCOV_EXCL_STOP + } + } + + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 6: l_estatus is eFrameworkunifiedStatusOK + // create writer thread + if (NULL != (m_hNSWriteThread = FrameworkunifiedCreateChildThreadWithPriority(f_happ, m_cWriteThreadName.c_str(), NSPCopyWorkerOnStart, NSPCopyWorkerOnStop, CNSNPP::m_siWriteThreadPrio))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + "Thread %s created, Prio=%d", + m_cWriteThreadName.c_str(), + CNSNPP::m_siWriteThreadPrio); + + // start the writer thread + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedStartChildThread(f_happ, m_hNSWriteThread, 0, NULL))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + m_pPersistenceManager->SetWriteThreadHandle(m_hNSWriteThread); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Fail to Start Write Worker thread. Status:0x%x", l_estatus); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error creating NPP Write Worker thread"); + // LCOV_EXCL_STOP + } + } + + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 6: l_estatus is eFrameworkunifiedStatusOK + // create immediate Persistence thread + if (NULL != (m_hNSImmediatePersistenceThread = FrameworkunifiedCreateChildThreadWithPriority(f_happ, m_cImmediatePersistenceThreadName.c_str(), NSPNorPersistenceWorkerOnStart, NSPNorPersistenceWorkerOnStop, CNSNPP::m_siImmediatePersistenceThreadPrio))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Thread %s created, Prio=%d", m_cImmediatePersistenceThreadName.c_str(), + CNSNPP::m_siImmediatePersistenceThreadPrio); + + // start the immediate Persistence thread + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedStartChildThread(f_happ, m_hNSImmediatePersistenceThread, 0, NULL))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + m_pPersistenceManager->SetNorPersistenceThreadHandle(m_hNSImmediatePersistenceThread); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Fail to Start immediate persistence thread. Status:0x%x", l_estatus); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error creating NPP immediate persistence Worker thread"); + // LCOV_EXCL_STOP + } + } + + return l_estatus; +} diff --git a/service/native/notification_persistent_service/server/src/ns_npp_archive.cpp b/service/native/notification_persistent_service/server/src/ns_npp_archive.cpp new file mode 100755 index 0000000..b54faeb --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_archive.cpp @@ -0,0 +1,846 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains the implementation for archiving and extracting files and folders. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +#ifdef AGL_STUB +#include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_fs_directory.h" +#include "ns_npp_copy_worker.h" + + +tartype_t g_gztype = { (openfunc_t) OpenArchive, (closefunc_t) CloseArchive, + (readfunc_t) ReadArchive, (writefunc_t) WriteArchive + }; + +GZFiles g_gzfiles; + +// CHUNK Size 256 Kb +// Buffer size for feeding data to and pulling data from the zlib routines +const size_t kChunkSize = 1U << 18; +// buff size 32KB +const size_t kBufSize = 1U << 15; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CArchive +/// Constructor of CArchive class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CCopyWorker::CArchive::CArchive() { +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CArchive +/// Destructor of CArchive class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CCopyWorker::CArchive::~CArchive() { +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// FolderOperation +/// Method to perform archive or extract operations +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::CArchive::Archive(NSP_CopyInfoCmd &f_tarchiveinfocmd, + NSP_CopyStatusResponse &f_tarchivestatusresponse) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + std::string l_pSourcePath = f_tarchiveinfocmd.m_csourcepath; + std::string l_pDestPath = f_tarchiveinfocmd.m_cdestinationpath; + + if (!l_pSourcePath.empty() || !l_pDestPath.empty()) { // LCOV_EXCL_BR_LINE 6: double check, l_pSourcePath and l_pDestPath can't be empty // NOLINT[whitespace/line_length] + size_t l_ifound = l_pDestPath.rfind("/"); + // get string from start to last occurrence of '/'. Which will return directory path + std::string l_cOutDirPath = l_pDestPath.substr(0, l_ifound); + // check for load file or release file + if (LOADTYPE_RELEASE == f_tarchiveinfocmd.m_eloadtype) { + if (CFSDirectory::DoesDirecotryExist(l_pSourcePath)) { + // check if destination directory exist + if (!CFSDirectory::DoesDirecotryExist(l_cOutDirPath)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "%s DOESN'T exist, Creating...", + l_cOutDirPath.c_str()); + l_estatus = CFSDirectory::CreateDirectory(l_cOutDirPath); + } + // Create archive + if (eFrameworkunifiedStatusOK == (l_estatus = CreateTar(l_pSourcePath, l_pDestPath, // LCOV_EXCL_BR_LINE 6: CreateTar always return eFrameworkunifiedStatusOK // NOLINT[whitespace/line_length] + f_tarchivestatusresponse))) { + // sync tar file to persistent memory + SI_32 l_iTarHandle = LIBTARFAIL; + if (LIBTARFAIL != (l_iTarHandle = open(l_pDestPath.c_str() , O_RDONLY))) { + struct stat l_objStat; + if (-1 != fstat(l_iTarHandle , &l_objStat)) { // LCOV_EXCL_BR_LINE 6: fstat always return ok + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO3, __FUNCTION__, "Bytes written in NAND memory, %ld, file=%s", l_objStat.st_size, + l_pDestPath.c_str()); + } + + close(l_iTarHandle); + } else { + l_estatus = eFrameworkunifiedStatusFail; + } + } else { + // LCOV_EXCL_START 6: CreateTar always return eFrameworkunifiedStatusOK + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Create tar Failed."); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "CP_WRK_FAILURE_SRC_NOT_FND for %s ", + l_pSourcePath.c_str()); + l_estatus = eFrameworkunifiedStatusFail; + } + } else { + // check if destination directory exist + if (!CFSDirectory::DoesDirecotryExist(l_pDestPath)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "%s DOESN'T exist, Creating...", + l_pDestPath.c_str()); + l_estatus = CFSDirectory::CreateDirectory(l_pDestPath); + } + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 6: l_estatus will be always eFrameworkunifiedStatusOK + // Extract archive + l_estatus = ExtractTar(l_pSourcePath, l_pDestPath, f_tarchivestatusresponse); + } + } + } else { + // LCOV_EXCL_START 6: double check, l_pSourcePath and l_pDestPath can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Source path or Dest Path empty."); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + + +//////////////////////////////////////////////////////////////////////////////////////////// +/// CreateTar +/// Method to create tar +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::CArchive::CreateTar(const std::string &f_csourepath, + const std::string &f_cdestpath, + NSP_CopyStatusResponse &f_tarchivestatusresponse) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + std::string l_cDestPath = f_cdestpath; + std::string l_pcRootDirPath = f_csourepath; + + libtar_list_t *l_pLibTarList = NULL; + l_pLibTarList = libtar_list_new(LIST_QUEUE, NULL); + libtar_list_add(l_pLibTarList, (void *)l_pcRootDirPath.c_str()); // NOLINT (readability/casting) + + if (!l_cDestPath.empty() || !l_pcRootDirPath.empty()) { // LCOV_EXCL_BR_LINE 6: double check, l_cDestPath and l_pcRootDirPath cannot be empty // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK != Create(l_cDestPath, l_pcRootDirPath, l_pLibTarList)) { // LCOV_EXCL_BR_LINE 6: Create always return eFrameworkunifiedStatusOK // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: Create always return eFrameworkunifiedStatusOK + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + // not copied properly so remove temporary file + if (TRUE == CFSDirectory::RemoveDirectory(l_cDestPath)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Delete persistent directory successful."); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Delete persistent directory unsuccessful."); + } + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Archiving fails for %s to %s", l_pcRootDirPath.c_str(), + l_cDestPath.c_str()); + // LCOV_EXCL_STOP + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "Folder archived %s ", l_cDestPath.c_str()); + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Source Path %s", l_pcRootDirPath.c_str()); + + if (TRUE == CFSDirectory::RemoveDirectory(l_pcRootDirPath)) { // LCOV_EXCL_BR_LINE 6: always return true + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Delete temporary directory successful."); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Delete temporary directory unsuccessful."); // LCOV_EXCL_LINE 6: always return true // NOLINT[whitespace/line_length] + } + l_estatus = eFrameworkunifiedStatusOK; + } + } else { + // LCOV_EXCL_START 6: double check, l_cDestPath and l_pcRootDirPath cannot be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Source path or Dest Path empty."); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + libtar_list_free(l_pLibTarList, NULL); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// ExtractTar +/// Method to extract tar +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::CArchive::ExtractTar(const std::string &f_csourepath, + const std::string &f_cdestpath, + NSP_CopyStatusResponse &f_tarchivestatusresponse) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + std::string l_pcTarFileDestPath = f_cdestpath; + std::string l_pcRootDirPath = f_csourepath; + + if (!l_pcTarFileDestPath.empty() || !l_pcRootDirPath.empty()) { // LCOV_EXCL_BR_LINE 6: double check, l_pcTarFileDestPath and l_pcRootDirPath can't be empty // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK != Extract(l_pcRootDirPath, l_pcTarFileDestPath)) { + // not copied properly so remove temporary file + if (TRUE == CFSDirectory::RemoveDirectory(l_pcTarFileDestPath)) { // LCOV_EXCL_BR_LINE 6: RemoveDirectory always return true // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Delete retrieved directory successful."); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Delete retrieved directory unsuccessful."); // LCOV_EXCL_LINE 6: RemoveDirectory always return true // NOLINT[whitespace/line_length] + } + + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "ABORT WAS CALLED!"); + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Extraction fails for %s to %s", + l_pcTarFileDestPath.c_str(), l_pcTarFileDestPath.c_str()); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "Folder extracted %s ", l_pcTarFileDestPath.c_str()); + l_estatus = eFrameworkunifiedStatusOK; + } + } else { + // LCOV_EXCL_START 6: double check, l_pcTarFileDestPath and l_pcRootDirPath can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Source path or Dest Path empty."); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// Create +/// Method to create tar +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::CArchive::Create(std::string &f_pctarfiledestpath, + std::string &f_pcrootdirpath, + libtar_list_t *f_plibtarlist) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (FILEERROR == access(f_pcrootdirpath.c_str(), R_OK)) { // LCOV_EXCL_BR_LINE 6: access always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + return eFrameworkunifiedStatusFail; // LCOV_EXCL_LINE 6: access always return ok + } + + TAR *l_pTarInfo = NULL; + CHAR l_cBuffer[MAX_PATH_LENGTH]; + libtar_listptr_t l_pTarListPtr; + + PCHAR l_pcTarFileDestPath = const_cast(f_pctarfiledestpath.c_str()); + PCHAR l_pcRootDirPath = const_cast(f_pcrootdirpath.c_str()); + + CHAR l_temp[] = "/"; + + if (l_pcTarFileDestPath || l_pcRootDirPath) { // LCOV_EXCL_BR_LINE 6: double check, l_pcTarFileDestPath and l_pcRootDirPath can't be NULL // NOLINT[whitespace/line_length] + // open tar archive + if (LIBTARFAIL == (tar_open(&l_pTarInfo, l_pcTarFileDestPath, &g_gztype, O_WRONLY | O_CREAT, // LCOV_EXCL_BR_LINE 6: tar_open always return ok // NOLINT[whitespace/line_length] + TARMODE, TAR_GNU))) { + // LCOV_EXCL_START 6: tar_open always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "tar_open(): %s", std::strerror(errno)); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + + libtar_listptr_reset(&l_pTarListPtr); + + while (libtar_list_next(f_plibtarlist, &l_pTarListPtr) != LIBTARSUCCESS) { + if (l_pcRootDirPath[0] != '/') { // LCOV_EXCL_BR_LINE 6: l_pcRootDirPath must begin with '/' + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "%s", l_pcRootDirPath); // LCOV_EXCL_LINE 6: l_pcRootDirPath must begin with '/' // NOLINT[whitespace/line_length] + } else { +#ifdef AGL_PosixBasedOS001LEGACY_USED + strlcpy(l_cBuffer, l_pcRootDirPath, sizeof(l_cBuffer)); +#endif + } + + if (tar_append_tree(l_pTarInfo, l_cBuffer, l_temp) != LIBTARSUCCESS) { // LCOV_EXCL_BR_LINE 6: tar_append_tree always return ok // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: tar_append_tree always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, + "tar_append_tree(\"%s\", \"%s\"): %s", l_cBuffer, + l_temp, std::strerror(errno)); + tar_close(l_pTarInfo); + return eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + } + if (tar_append_eof(l_pTarInfo) != LIBTARSUCCESS) { // LCOV_EXCL_BR_LINE 6: tar_append_eof always return ok + // LCOV_EXCL_START 6: tar_append_eof always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "tar_append_eof(): %s", std::strerror(errno)); + tar_close(l_pTarInfo); + return eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + + if (tar_close(l_pTarInfo) != LIBTARSUCCESS) { // LCOV_EXCL_BR_LINE 6: tar_close always return ok + // LCOV_EXCL_START 6: tar_close always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "tar_close(): %s", std::strerror(errno)); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: double check, l_pcTarFileDestPath and l_pcRootDirPath can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Source path or Dest Path empty."); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// create +/// Method to extract tar +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::CArchive::Extract(std::string &f_pcrootdirpath, std::string &f_pctarfiledestpath) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (FILEERROR == access(f_pcrootdirpath.c_str(), R_OK)) { // LCOV_EXCL_BR_LINE 6: access always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + return eFrameworkunifiedStatusFail; // LCOV_EXCL_LINE 6: access always return ok + } + + PCHAR l_pcRootDirPath = const_cast(f_pcrootdirpath.c_str()); + PCHAR l_pcTarFileDestPath = const_cast(f_pctarfiledestpath.c_str()); + + TAR *l_pTarInfo = NULL; + + if (l_pcRootDirPath || l_pcTarFileDestPath) { // LCOV_EXCL_BR_LINE 6: double check, l_pcRootDirPath and l_pcTarFileDestPath can't be NULL // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Extraction open for %s to ", l_pcRootDirPath); + + if (LIBTARFAIL == (tar_open(&l_pTarInfo, l_pcRootDirPath, &g_gztype, O_RDONLY, LIBTARSUCCESS, TAR_GNU))) { // LCOV_EXCL_BR_LINE 6: tar_open always return ok // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: tar_open always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "tar_open(): %s", std::strerror(errno)); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + + if (LIBTARSUCCESS != tar_extract_all(l_pTarInfo, l_pcTarFileDestPath)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "tar_extract_all(): %s", std::strerror(errno)); + l_estatus = eFrameworkunifiedStatusFail; + } + + if (LIBTARSUCCESS != tar_close(l_pTarInfo)) { // LCOV_EXCL_BR_LINE 6: tar_close always return ok + // LCOV_EXCL_START 6: tar_close always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "tar_close(): %s", std::strerror(errno)); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: double check, l_pcRootDirPath and l_pcTarFileDestPath can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Source path or Dest Path empty."); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +SI_32 OpenArchive(PCHAR f_pcpathname, SI_32 f_sioflags, SI_32 f_simode) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + gzFile l_gzfile = Z_NULL; + SI_32 l_sifiledescriptor = LIBTARFAIL; + if (f_pcpathname) { // LCOV_EXCL_BR_LINE 6: double check, f_pcpathname can't be NULL + PCHAR l_pcgzoflags; + + switch (f_sioflags & O_ACCMODE) { + case O_WRONLY: { + l_pcgzoflags = (PCHAR)"wb"; + break; + } + case O_RDONLY: { + l_pcgzoflags = (PCHAR)"rb"; + break; + } + case O_RDWR: + default: { + // LCOV_EXCL_START 6: must be O_WRONLY or O_RDONLY + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + errno = EINVAL; + return LIBTARFAIL; + // LCOV_EXCL_STOP + } + } + + l_sifiledescriptor = open(f_pcpathname, f_sioflags, f_simode); + + if (LIBTARFAIL == l_sifiledescriptor) { // LCOV_EXCL_BR_LINE 6: l_sifiledescriptor always be ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + return LIBTARFAIL; // LCOV_EXCL_LINE 6: l_sifiledescriptor always be ok + } + + if (((f_sioflags & O_CREAT) && fchmod(l_sifiledescriptor, f_simode))) { // LCOV_EXCL_BR_LINE 6: always be ok + // LCOV_EXCL_START 6: always be ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + close(l_sifiledescriptor); + return LIBTARFAIL; + // LCOV_EXCL_STOP + } + + l_gzfile = gzdopen(l_sifiledescriptor, l_pcgzoflags); + if (!l_gzfile) { // LCOV_EXCL_BR_LINE 6: l_gzfile always be not null + // LCOV_EXCL_START 6: l_gzfile always be not null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + close(l_sifiledescriptor); + + errno = ENOMEM; + return LIBTARFAIL; + // LCOV_EXCL_STOP + } else { + g_gzfiles.insert(std::make_pair(l_sifiledescriptor, l_gzfile)); + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Source Path empty."); // LCOV_EXCL_LINE 6: double check, f_pcpathname can't be NULL // NOLINT[whitespace/line_length] + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_sifiledescriptor; +} + +int CloseArchive(int fd) { + int ret; + gzFile gzfile = Z_NULL; + + /* checks */ + if (g_gzfiles.empty()) { // LCOV_EXCL_BR_LINE 6: g_gzfiles always be not empty + // LCOV_EXCL_START 6: g_gzfiles always be not empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + errno = EBADF; + return -1; + // LCOV_EXCL_STOP + } + + GZFiles::iterator gzfiles_it = g_gzfiles.find(fd); + if (gzfiles_it == g_gzfiles.end()) { // LCOV_EXCL_BR_LINE 6: fd will always be found + // LCOV_EXCL_START 6: fd will always be found + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + errno = EINVAL; + return -1; + // LCOV_EXCL_STOP + } + + /* call zlib */ + gzfile = gzfiles_it->second; + ret = gzclose(gzfile); + + /* remove gzFile* association from our list */ + g_gzfiles.erase(gzfiles_it); + + return ret; +} + +ssize_t ReadArchive(int fd, void *buf, size_t count) { + gzFile gzfile = Z_NULL; + + if (g_gzfiles.empty()) { // LCOV_EXCL_BR_LINE 6: g_gzfiles always be not empty + // LCOV_EXCL_START 6: g_gzfiles always be not empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + errno = EBADF; + return -1; + // LCOV_EXCL_STOP + } + + GZFiles::iterator gzfiles_it = g_gzfiles.find(fd); + if (gzfiles_it == g_gzfiles.end()) { // LCOV_EXCL_BR_LINE 6: fd will always be found + // LCOV_EXCL_START 6: fd will always be found + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + errno = EINVAL; + return -1; + // LCOV_EXCL_STOP + } + + gzfile = gzfiles_it->second; + return gzread(gzfile, buf, static_cast(count)); +} + +ssize_t WriteArchive(int fd, const void *buf, size_t count) { + gzFile gzfile = Z_NULL; + + if (g_gzfiles.empty()) { // LCOV_EXCL_BR_LINE 6: g_gzfiles always be not empty + // LCOV_EXCL_START 6: g_gzfiles always be not empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + errno = EBADF; + return -1; + // LCOV_EXCL_STOP + } + + GZFiles::iterator gzfiles_it = g_gzfiles.find(fd); + if (gzfiles_it == g_gzfiles.end()) { // LCOV_EXCL_BR_LINE 6: fd will always be found + // LCOV_EXCL_START 6: fd will always be found + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + errno = EINVAL; + return -1; + // LCOV_EXCL_STOP + } + + gzfile = gzfiles_it->second; + return gzwrite(gzfile, buf, static_cast(count)); +} + +// LCOV_EXCL_START 6: unused code +//////////////////////////////////////////////////////////////////////////////////////////// +/// FileOperationUsingLibz +/// Method to determine whether to compress/decompress file using libz +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::CArchive::FileOperationUsingLibz(NSP_CopyInfoCmd &f_toperainfocmd, + NSP_CopyStatusResponse &f_toperarespstatus) { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + std::string l_pSourcePath = f_toperainfocmd.m_csourcepath; + std::string l_pDestPath = f_toperainfocmd.m_cdestinationpath; + + if (!l_pSourcePath.empty() || !l_pDestPath.empty()) { + size_t l_ifound = l_pDestPath.rfind("/"); + // get string from start to last occurrence of '/'. Which will return directory path + std::string l_cOutDirPath = l_pDestPath.substr(0, l_ifound); + + // check if destination directory exist + if (!CFSDirectory::DoesDirecotryExist(l_cOutDirPath)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "%s DOESN'T exist, Creating...", + l_cOutDirPath.c_str()); + l_estatus = CFSDirectory::CreateDirectory(l_cOutDirPath); + } + + // check for load file or release file + if (LOADTYPE_RELEASE == f_toperainfocmd.m_eloadtype) { + // Zip + if (eFrameworkunifiedStatusOK == (l_estatus = CompressUsingZlib(l_pSourcePath, l_pDestPath, Z_BEST_COMPRESSION))) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "File Compression successful."); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "File Compression failed."); + f_toperarespstatus.m_bpersistencechk = FALSE; + l_estatus = eFrameworkunifiedStatusFail; + } + } else if (LOADTYPE_LOAD == f_toperainfocmd.m_eloadtype) { + // Unzip + if (eFrameworkunifiedStatusOK == (l_estatus = DeCompressUsingZlib(l_pSourcePath, l_pDestPath))) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "File DeCompression successful."); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "File DeCompression failed."); + f_toperarespstatus.m_bpersistencechk = FALSE; + l_estatus = eFrameworkunifiedStatusFail; + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "Wrong Request or No request for compression or decompression!"); + l_estatus = eFrameworkunifiedStatusFail; + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Source Path or Destination Path Empty."); + l_estatus = eFrameworkunifiedStatusFail; + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} +// LCOV_EXCL_STOP + +// LCOV_EXCL_START 6: unused code +//////////////////////////////////////////////////////////////////////////////////////////// +/// CompressUsingZlib +/// Method to compress file using libz +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::CArchive::CompressUsingZlib(const std::string &f_csourepath, + const std::string &f_cdestpath, + SI_32 f_iziplevel) { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (!f_csourepath.empty() || !f_cdestpath.empty()) { + std::string l_cSourePath = f_csourepath; + std::string l_cDestPath = f_cdestpath; + + std::string l_TempFile = ""; + l_TempFile.append(l_cDestPath.c_str()); + l_TempFile.append(".nps_tmp"); + + FILE *l_pSrcFilePtr = fopen(l_cSourePath.c_str(), "rb"); + + if (NULL != l_pSrcFilePtr) { + FILE *l_pDestFilePtr = fopen(l_TempFile.c_str(), "wb"); + if (NULL != l_pDestFilePtr) { + setvbuf(l_pSrcFilePtr, NULL, _IOFBF, kBufSize); + setvbuf(l_pDestFilePtr, NULL, _IOFBF, kBufSize); + + // structure used to pass information to and from the zlib routines + z_stream l_tZstreamInfo = {}; + + // Allocate deflate state + l_tZstreamInfo.zalloc = Z_NULL; + l_tZstreamInfo.zfree = Z_NULL; + l_tZstreamInfo.opaque = Z_NULL; + + // Initialize deflates + SI_32 l_iDeflateStatus = deflateInit(&l_tZstreamInfo, f_iziplevel); + + // Deflate Flush Status to determine end of input file + SI_32 l_iDeflateFlushState = Z_FINISH; + + std::vector< UI_8 > l_vInBuffer(kChunkSize); + std::vector< UI_8 > l_vOutBuffer(kChunkSize); + + // pointer to the read bytes from the input file + UI_8 *l_pReadBuffer = &l_vInBuffer[0]; + // pointer to the next available byte space to write to output file + UI_8 *l_pWriteBuffer = &l_vOutBuffer[0]; + + size_t l_uiDeflateRetData = 0; + + if (Z_OK == l_iDeflateStatus) { + do { + // bytes read from input file + l_tZstreamInfo.avail_in = static_cast(fread(l_pReadBuffer, 1, kChunkSize, l_pSrcFilePtr)); + + if (0 == ferror(l_pSrcFilePtr)) { + // if the eof input file reached set the flush state to Z_FINISH + // Z_NO_FLUSH to indicate that we still have uncompressed data + l_iDeflateFlushState = feof(l_pSrcFilePtr) ? Z_FINISH : Z_NO_FLUSH; + l_tZstreamInfo.next_in = l_pReadBuffer; + + // run deflate() on input until output buffer not full, finish + // compression if all of source has been read in + do { + l_tZstreamInfo.avail_out = kChunkSize; + l_tZstreamInfo.next_out = l_pWriteBuffer; + // no bad return value + l_iDeflateStatus = deflate(&l_tZstreamInfo, l_iDeflateFlushState); + // state not clobbered + if (Z_STREAM_ERROR == l_iDeflateStatus) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "zlib stream error"); + } else { + l_uiDeflateRetData = kChunkSize - l_tZstreamInfo.avail_out; + if ((fwrite(l_pWriteBuffer, 1, l_uiDeflateRetData, l_pDestFilePtr) != l_uiDeflateRetData) || + // all data not written properly + (0 != ferror(l_pDestFilePtr))) { // file error in writing + deflateEnd(&l_tZstreamInfo); + l_estatus = eFrameworkunifiedStatusFail; + l_tZstreamInfo.avail_out = 0; + l_iDeflateFlushState = Z_FINISH; + } + } + } while (0 == l_tZstreamInfo.avail_out); //<< check if deflate() has no more output + } else { // by seeing that it did not fill the output buffer + deflateEnd(&l_tZstreamInfo); // leaving avail_out greater than zero >>// + l_estatus = eFrameworkunifiedStatusFail; + } + + // all input will be used + if (0 != l_tZstreamInfo.avail_in) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "All inputs in z-stream avail_in not used"); + l_estatus = eFrameworkunifiedStatusFail; + } + // done when last data in file processed + } while (Z_FINISH != l_iDeflateFlushState); + // stream will be complete + if (Z_STREAM_END != l_iDeflateStatus) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "z-stream not completed"); + l_estatus = eFrameworkunifiedStatusFail; + } + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Compressed %lu bytes down to %lu bytes", + l_tZstreamInfo.total_in, l_tZstreamInfo.total_out); + + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO3, __FUNCTION__, "Bytes written in NAND memory, %lu, file=%s", l_tZstreamInfo.total_out, + f_cdestpath.c_str()); + + // clean up and return + deflateEnd(&l_tZstreamInfo); + } else { + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "deflateInit Failed"); + } + + fclose(l_pDestFilePtr); + + if (0 != rename(l_TempFile.c_str(), l_cDestPath.c_str())) { + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "Error renaming file %s to %s", + l_TempFile.c_str(), l_cDestPath.c_str()); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "Destination File Opening Error"); + l_estatus = eFrameworkunifiedStatusFail; + } + fclose(l_pSrcFilePtr); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "Source File Opening Error"); + l_estatus = eFrameworkunifiedStatusFail; + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Source Path or Destination Path Empty."); + l_estatus = eFrameworkunifiedStatusFail; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} +// LCOV_EXCL_STOP + +// LCOV_EXCL_START 6: unused code +//////////////////////////////////////////////////////////////////////////////////////////// +/// DeCompressUsingZlib +/// Method to decompress file using libz +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::CArchive::DeCompressUsingZlib(const std::string &f_csourepath, + const std::string &f_cdestpath) { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (!f_csourepath.empty() || !f_cdestpath.empty()) { + std::string l_cSourePath = f_csourepath; + std::string l_cDestPath = f_cdestpath; + + std::string l_TempFile = ""; + l_TempFile.append(l_cDestPath.c_str()); + l_TempFile.append(".nps_tmp"); + + FILE *l_pSrcFilePtr = fopen(l_cSourePath.c_str(), "rb"); + + if (NULL != l_pSrcFilePtr) { + FILE *l_pDestFilePtr = fopen(l_TempFile.c_str(), "wb"); + if (NULL != l_pDestFilePtr) { + setvbuf(l_pSrcFilePtr, NULL, _IOFBF, kBufSize); + setvbuf(l_pDestFilePtr, NULL, _IOFBF, kBufSize); + + z_stream l_tZstreamInfo = {}; + + // allocate inflate state + l_tZstreamInfo.zalloc = Z_NULL; + l_tZstreamInfo.zfree = Z_NULL; + l_tZstreamInfo.opaque = Z_NULL; + l_tZstreamInfo.avail_in = 0; + l_tZstreamInfo.next_in = Z_NULL; + + SI_32 l_iInflateStatus = inflateInit(&l_tZstreamInfo); + + if (Z_OK == l_iInflateStatus) { + std::vector< UI_8 > l_vInBuffer(kChunkSize); + std::vector< UI_8 > l_vOutBuffer(kChunkSize); + + // pointer to the read bytes from the input file + UI_8 *l_pReadBuffer = &l_vInBuffer[0]; + // pointer to the next available byte space to write to output file + UI_8 *l_pWriteBuffer = &l_vOutBuffer[0]; + + size_t l_uiDeflateRetData = 0; + + do { + l_tZstreamInfo.avail_in = static_cast(fread(l_pReadBuffer, 1, kChunkSize, l_pSrcFilePtr)); + if (0 == ferror(l_pSrcFilePtr)) { + if (0 == l_tZstreamInfo.avail_in) { + break; + } + l_tZstreamInfo.next_in = l_pReadBuffer; + // run inflate() on input until output buffer not full + do { + l_tZstreamInfo.avail_out = kChunkSize; + l_tZstreamInfo.next_out = l_pWriteBuffer; + l_iInflateStatus = inflate(&l_tZstreamInfo, Z_NO_FLUSH); + + // state clobbered + if (Z_STREAM_ERROR == l_iInflateStatus) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "zlib stream error"); + l_estatus = eFrameworkunifiedStatusFail; + } else if (Z_NEED_DICT == l_iInflateStatus) { + l_iInflateStatus = Z_DATA_ERROR; + l_estatus = eFrameworkunifiedStatusFail; + } else if (Z_MEM_ERROR == l_iInflateStatus) { + inflateEnd(&l_tZstreamInfo); + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Out of Memory"); + } else { + l_uiDeflateRetData = kChunkSize - l_tZstreamInfo.avail_out; + // all data not written + if ((fwrite(l_pWriteBuffer, 1, l_uiDeflateRetData, l_pDestFilePtr) != l_uiDeflateRetData) || + (0 != ferror(l_pDestFilePtr))) { // or file writing error + inflateEnd(&l_tZstreamInfo); + l_estatus = eFrameworkunifiedStatusFail; + } + } + } while (0 == l_tZstreamInfo.avail_out); + } else { + inflateEnd(&l_tZstreamInfo); + l_estatus = eFrameworkunifiedStatusFail; + } + + // done when inflate() says it's done + } while (Z_STREAM_END != l_iInflateStatus); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " De-compressed %lu bytes to %lu bytes", + l_tZstreamInfo.total_in, l_tZstreamInfo.total_out); + // clean up and return + inflateEnd(&l_tZstreamInfo); + } else { + l_estatus = eFrameworkunifiedStatusFail; + } + + fclose(l_pDestFilePtr); + + if (0 != rename(l_TempFile.c_str(), l_cDestPath.c_str())) { + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "Error renaming file %s to %s", + l_TempFile.c_str(), l_cDestPath.c_str()); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "Destination File Opening Error"); + l_estatus = eFrameworkunifiedStatusFail; + } + fclose(l_pSrcFilePtr); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "Source File Opening Error"); + l_estatus = eFrameworkunifiedStatusFail; + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Source Path or Destination Path Empty."); + l_estatus = eFrameworkunifiedStatusFail; + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} +// LCOV_EXCL_STOP diff --git a/service/native/notification_persistent_service/server/src/ns_npp_binary_accesser.cpp b/service/native/notification_persistent_service/server/src/ns_npp_binary_accesser.cpp new file mode 100755 index 0000000..e0a749f --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_binary_accesser.cpp @@ -0,0 +1,649 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NPPService +/// \brief The file contains definition of CBinaryAccesser class. +/// This class stores data in a file in binary format. +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include +#include +#include +#include +#ifdef AGL_STUB +#include +#endif +#include +#include +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_fs_directory.h" +#include "ns_npp_binary_accesser.h" +#include "ns_npp_persistent_data.h" +#include "ns_npp_persistent_accesser.h" + +struct PersistFileHeder { + char check_code[4]; + unsigned int crc; +}; +#define NPP_CHECK_CODE "NPPD" + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// CBinaryAccesser +/// Constructor of CBinaryAccesser class +//////////////////////////////////////////////////////////////////////////////////////////////// +CBinaryAccesser::CBinaryAccesser() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_uiCurStrOffset = 0; + m_uiCurStrSize = 0; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CBinaryAccesser +/// Destructor of CBinaryAccesser class +//////////////////////////////////////////////////////////////////////////////////////////////// +CBinaryAccesser::~CBinaryAccesser() { // LCOV_EXCL_START 14: Resident process, global instance not released + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// PersistData +/// Persist data in persistent memory in a file in binary format. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CBinaryAccesser::PersistData(std::string f_cmemfilepath, + Persistent_Notification_List_Type *f_vdata, + EFrameworkunifiedNotificationType f_epersistenttype, + EFrameworkunifiedPersistCategory f_epersistcategory) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + int l_OutFd; + + if (NULL != f_vdata) { // LCOV_EXCL_BR_LINE 6: f_vdata can't be NULL + // Open global file in write mode. + if ((eFrameworkunifiedStatusOK == OpenFileForWriting(&l_OutFd, f_cmemfilepath))) { + Persistent_Notification_List_Iterator l_itNotificationList = f_vdata->begin(); + + // Iterate through a vector f_vdata + for (; l_itNotificationList != f_vdata->end(); l_itNotificationList++) { + if (eFrameworkunifiedPersistedStateVar == (*l_itNotificationList)->m_ePersistentType) { + if (f_epersistcategory == (*l_itNotificationList)->m_ePersistCategory) { + // write header and data + if (eFrameworkunifiedStatusOK != WriteHeaderAndData((*l_itNotificationList), + (*l_itNotificationList)->m_pPersistentData->m_pMessage, + l_OutFd)) { + l_estatus = eFrameworkunifiedStatusFail; + break; + } + } + } else { + // write header and data + if (eFrameworkunifiedStatusOK != WriteHeaderAndData((*l_itNotificationList), + (*l_itNotificationList)->m_pPersistentData->m_pMessage, + l_OutFd)) { + l_estatus = eFrameworkunifiedStatusFail; + break; + } + } + } + + if (eFrameworkunifiedStatusOK != WriteFileHeaderAndDuplicate(l_OutFd, f_cmemfilepath)) { + l_estatus = eFrameworkunifiedStatusFail; + } else { + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO3, __FUNCTION__, "Bytes written in NAND memory, %ld, file=%s", + static_cast(m_uiCurStrOffset - sizeof(PersistFileHeder)), f_cmemfilepath.c_str()); // NOLINT (runtime/int) + } + close(l_OutFd); + } else { + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to open file %s", f_cmemfilepath.c_str()); + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// RetrieveData +/// Retrieve data in persistent memory in a file in binary format. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CBinaryAccesser::RetrieveData(std::string f_cmemfilepath, + Persistent_Notification_List_Type *&f_vdata, + EFrameworkunifiedPersistCategory f_epersistcategory) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + int l_InFd; + + if (NULL != f_vdata) { // LCOV_EXCL_BR_LINE 6: f_vdata can't be NULL + if ((eFrameworkunifiedStatusOK == (l_estatus = OpenFileForReading(&l_InFd, f_cmemfilepath)))) { + l_estatus = FillNotificationList(l_InFd, f_vdata, f_epersistcategory); + + close(l_InFd); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to open file %s, status=%d", f_cmemfilepath.c_str(), l_estatus); + } + } else { + // LCOV_EXCL_START 6: f_vdata can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "f_pdata is NULL"); + l_estatus = eFrameworkunifiedStatusInvldParam; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// FillNotificationList +/// This function retrieve the notification data from file and fill it in map. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CBinaryAccesser::FillNotificationList(int f_infd, + Persistent_Notification_List_Type *&f_vdata, + EFrameworkunifiedPersistCategory f_epersistcategory) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL == f_vdata) { // LCOV_EXCL_BR_LINE 6: f_vdata can't be NULL + // LCOV_EXCL_START 6: f_vdata can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "f_pdata is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } else { + while (eFrameworkunifiedStatusOK == l_estatus) { + CPersistDataHeader l_objCPersistDataHeader; + CHAR *l_pData = NULL; + + // Read header and data. + l_estatus = ReadHeaderAndData(l_objCPersistDataHeader, l_pData, f_infd); + if (eFrameworkunifiedStatusOK == l_estatus) { + CNotificationsToPersist *l_objCNotificationsToPersist = new(std::nothrow) CNotificationsToPersist(); + CPersistentData *l_objCPersistentData = new(std::nothrow) CPersistentData(); + + // fill the appropriate values in l_objCNotificationsToPersist + if ((NULL != l_objCPersistentData) && (NULL != l_objCNotificationsToPersist)) { // LCOV_EXCL_BR_LINE 5: new's error case // NOLINT[whitespace/line_length] + l_objCPersistentData->m_pMessage = new(std::nothrow) CHAR[l_objCPersistDataHeader.m_uiSize]; + if (NULL != l_objCPersistentData->m_pMessage) { // LCOV_EXCL_BR_LINE 5: new's error case + std::memcpy(l_objCPersistentData->m_pMessage, l_pData, l_objCPersistDataHeader.m_uiSize); + l_objCPersistentData->m_uiMsgSize = l_objCPersistDataHeader.m_uiSize; + l_objCNotificationsToPersist->m_ePersistentType = l_objCPersistDataHeader.m_ePersistentType; + l_objCNotificationsToPersist->m_ePersistCategory = f_epersistcategory; + + l_objCNotificationsToPersist->m_cNotificationName = l_objCPersistDataHeader.m_cNotificationName; + l_objCNotificationsToPersist->m_cPublisherName = l_objCPersistDataHeader.m_cPublisherName; + + l_objCNotificationsToPersist->m_pPersistentData = l_objCPersistentData; + + l_objCNotificationsToPersist->m_uiMaxMsgLength = l_objCPersistDataHeader.m_uiMaxMsgLength; + f_vdata->push_back(l_objCNotificationsToPersist); + } else { + // LCOV_EXCL_START 5: new's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + std::memset(&l_objCPersistDataHeader, 0, sizeof(CPersistDataHeader)); + l_estatus = eFrameworkunifiedStatusNullPointer; + break; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 5: new's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + std::memset(&l_objCPersistDataHeader, 0, sizeof(CPersistDataHeader)); + l_estatus = eFrameworkunifiedStatusNullPointer; + break; + // LCOV_EXCL_STOP + } + } else if (eFrameworkunifiedStatusErrOther == l_estatus) { + // EOF + l_estatus = eFrameworkunifiedStatusOK; + break; + } else { + std::memset(&l_objCPersistDataHeader, 0, sizeof(CPersistDataHeader)); + break; + } + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CBinaryAccesser::OpenFileForReading(int *f_infd, + std::string f_cfilepath) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // raw & raw.bak file unlink + std::string l_cUnlinkPath(f_cfilepath); + unlink(l_cUnlinkPath.c_str()); + l_cUnlinkPath.append(".bak"); + unlink(l_cUnlinkPath.c_str()); + + // add .valid + std::string l_cValidPath(f_cfilepath); + l_cValidPath.append(".valid"); + + if ((*f_infd = open(l_cValidPath.c_str(), O_RDONLY)) >= 0) { + if (eFrameworkunifiedStatusOK == CheckFileHeader(*f_infd)) { + struct stat st; + if (fstat(*f_infd, &st) == 0) { // LCOV_EXCL_BR_LINE 5: fstat's error case + if (st.st_size == 0) { + // If original file is 0byte, to confirm bak file + int bak_fd; + if (eFrameworkunifiedStatusOK == OpenBakFileForReading(&bak_fd, l_cValidPath)) { + close(*f_infd); + *f_infd = bak_fd; + } + } + } + l_estatus = eFrameworkunifiedStatusOK; + } else { + close(*f_infd); + l_estatus = OpenBakFileForReading(f_infd, l_cValidPath); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "open(%s) fail: %s", l_cValidPath.c_str(), strerror(errno)); + l_estatus = OpenBakFileForReading(f_infd, l_cValidPath); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// OpenFileForWriting +/// +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CBinaryAccesser::OpenFileForWriting(int *f_outfd, + std::string f_cfilepath) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + + std::string l_cPath(f_cfilepath); + size_t l_ifound = l_cPath.rfind("/"); + std::string l_cOutDirPath = l_cPath.substr(0, l_ifound); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Path for persistence %s ", l_cOutDirPath.c_str()); + + // if parent directory path doesn't exists, create it + if (!CFSDirectory::DoesDirecotryExist(l_cOutDirPath)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "%s DOESN'T exist, Creating...", l_cOutDirPath.c_str()); + if (eFrameworkunifiedStatusOK != (l_estatus = CFSDirectory::CreateDirectory(l_cOutDirPath))) { // LCOV_EXCL_BR_LINE 6: CreateDirectory always return ok // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Failed to create %s ", l_cOutDirPath.c_str()); // LCOV_EXCL_LINE 6: CreateDirectory always return ok // NOLINT[whitespace/line_length] + } + } + + // add .valid + std::string l_cValidPath(f_cfilepath); + l_cValidPath.append(".valid"); + + if ((*f_outfd = open(l_cValidPath.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0660)) >= 0) { + if (lseek(*f_outfd, sizeof(PersistFileHeder), SEEK_SET) == sizeof(PersistFileHeder)) { // LCOV_EXCL_BR_LINE 5: lseek's error case // NOLINT[whitespace/line_length] + l_estatus = eFrameworkunifiedStatusOK; + m_uiCurStrOffset = sizeof(PersistFileHeder); + } else { + // LCOV_EXCL_START 5: lseek's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "lseek fail: %s", strerror(errno)); + close(*f_outfd); + *f_outfd = -1; + // LCOV_EXCL_STOP + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "open(%s) fail: %s", l_cValidPath.c_str(), strerror(errno)); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// WriteHeaderAndData +/// Write header and data in a file. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CBinaryAccesser::WriteHeaderAndData(CNotificationsToPersist *f_pnotificationstopersist, + PVOID f_pdata, + int f_outfd) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + + if ((NULL == f_pdata) || (NULL == f_pnotificationstopersist)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "f_pdata is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + } else { + CPersistDataHeader l_objCPersistDataHeader; + +#ifdef AGL_PosixBasedOS001LEGACY_USED + strlcpy(l_objCPersistDataHeader.m_cNotificationName, f_pnotificationstopersist->m_cNotificationName.c_str(), + sizeof(l_objCPersistDataHeader.m_cNotificationName)); + strlcpy(l_objCPersistDataHeader.m_cPublisherName, f_pnotificationstopersist->m_cPublisherName.c_str(), + sizeof(l_objCPersistDataHeader.m_cPublisherName)); +#endif + + // size check + if (UINT32_MAX >= static_cast(sizeof(CPersistDataHeader) + l_objCPersistDataHeader.m_uiSize)) { // LCOV_EXCL_BR_LINE 5: the size is not bigger than UINT32_MAX // NOLINT[whitespace/line_length] + l_objCPersistDataHeader.m_uiOffset = static_cast(m_uiCurStrOffset + sizeof(CPersistDataHeader)); + l_objCPersistDataHeader.m_uiSize = f_pnotificationstopersist->m_pPersistentData->m_uiMsgSize; + l_objCPersistDataHeader.m_ePersistentType = f_pnotificationstopersist->m_ePersistentType; + l_objCPersistDataHeader.m_uiMaxMsgLength = f_pnotificationstopersist->m_uiMaxMsgLength; + + // write header + if (write(f_outfd, (PCHAR)&l_objCPersistDataHeader, sizeof(CPersistDataHeader)) == sizeof(CPersistDataHeader)) { // LCOV_EXCL_BR_LINE 5: write's error case // NOLINT[whitespace/line_length] + // write data + if (write(f_outfd, (PCHAR)f_pdata, // LCOV_EXCL_BR_LINE 5: write's error case + l_objCPersistDataHeader.m_uiSize) == (ssize_t)l_objCPersistDataHeader.m_uiSize) { + // save offset of end of current record's data + m_uiCurStrOffset += static_cast(sizeof(CPersistDataHeader) + l_objCPersistDataHeader.m_uiSize); + l_estatus = eFrameworkunifiedStatusOK; + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error while writing data: %s", strerror(errno)); // LCOV_EXCL_LINE 5: lseek's error case // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error while writing header: %s", strerror(errno)); // LCOV_EXCL_LINE 5: lseek's error case // NOLINT[whitespace/line_length] + } + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CBinaryAccesser::ReadHeaderAndData(CPersistDataHeader &f_objcpersistdataheader, + CHAR *&f_pdata, int f_infd) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + static UI_32 l_uisPrevAllocSz = 0; + ssize_t l_iRet; + + // read header + l_iRet = read(f_infd, (PCHAR)&f_objcpersistdataheader, sizeof(f_objcpersistdataheader)); + if (l_iRet != sizeof(f_objcpersistdataheader)) { + if (l_iRet < 0) { // LCOV_EXCL_BR_LINE 5: read's error case + // LCOV_EXCL_START 5: read's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error while reading header: %s", strerror(errno)); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } else { + l_estatus = eFrameworkunifiedStatusErrOther; // TODO(my_username): set specific error as eNotificationpersistentserviceStatusEOFReadched + } + std::memset(&f_objcpersistdataheader, 0, sizeof(CPersistDataHeader)); + } else { // read data + m_uiCurStrOffset += static_cast(sizeof(CPersistDataHeader)); + if (static_cast(f_objcpersistdataheader.m_uiSize) > 0 && + m_uiCurStrOffset + f_objcpersistdataheader.m_uiSize <= m_uiCurStrSize) { + // if f_pdata has space allocated and if the allocated size less than new size, + // free and reallocate + if ((NULL != f_pdata) && (l_uisPrevAllocSz < f_objcpersistdataheader.m_uiSize)) { // LCOV_EXCL_BR_LINE 6: f_pdata must be null // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: f_pdata must be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + delete[] f_pdata; + f_pdata = NULL; + // LCOV_EXCL_STOP + } + + if (NULL == f_pdata) { // LCOV_EXCL_BR_LINE 200: f_pdata must be null + f_pdata = new(std::nothrow) CHAR[f_objcpersistdataheader.m_uiSize]; + } else { + // memory already allcoated. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + } + + if (NULL != f_pdata) { // LCOV_EXCL_BR_LINE 6: f_pdata can't be null + l_uisPrevAllocSz = f_objcpersistdataheader.m_uiSize; + l_iRet = read(f_infd, (PCHAR)f_pdata, f_objcpersistdataheader.m_uiSize); + if (l_iRet == (ssize_t)f_objcpersistdataheader.m_uiSize) { // LCOV_EXCL_BR_LINE 5: read's error case + m_uiCurStrOffset += f_objcpersistdataheader.m_uiSize; + l_estatus = eFrameworkunifiedStatusOK; + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error while reading data: %s", strerror(errno)); // LCOV_EXCL_LINE 5: read's error case // NOLINT[whitespace/line_length] + } + } else { + // LCOV_EXCL_START 6: f_pdata can't be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Mem Allocation failure"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invlide data size: %u", f_objcpersistdataheader.m_uiSize); + std::memset(&f_objcpersistdataheader, 0, sizeof(CPersistDataHeader)); + l_estatus = eFrameworkunifiedStatusFail; + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +EFrameworkunifiedStatus CBinaryAccesser::WriteFileHeaderAndDuplicate(int f_outfd, std::string f_cfilepath) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusFail; + struct stat st; + + if (fstat(f_outfd, &st) == 0) { // LCOV_EXCL_BR_LINE 5: fstat's error case + if (st.st_size > static_cast(sizeof(PersistFileHeder))) { // NOLINT (runtime/int) + size_t body_size = static_cast(st.st_size - sizeof(PersistFileHeder)); + char *buf = new(std::nothrow) char[body_size]; + if (buf != NULL) { // LCOV_EXCL_BR_LINE 5: new's error case + if (lseek(f_outfd, sizeof(PersistFileHeder), SEEK_SET) == sizeof(PersistFileHeder)) { // LCOV_EXCL_BR_LINE 5: lseek's error case // NOLINT[whitespace/line_length] + if (read(f_outfd, buf, body_size) == static_cast(body_size)) { // LCOV_EXCL_BR_LINE 5: read's error case // NOLINT[whitespace/line_length] + PersistFileHeder f_header; + std::memcpy(&f_header.check_code, NPP_CHECK_CODE, sizeof(f_header.check_code)); + f_header.crc = static_cast(CalcCRC(buf, static_cast(body_size))); + if (lseek(f_outfd, 0, SEEK_SET) == 0) { // LCOV_EXCL_BR_LINE 5: lseek's error case + if (write(f_outfd, &f_header, sizeof(f_header)) == sizeof(f_header)) { // LCOV_EXCL_BR_LINE 5: write's error case // NOLINT[whitespace/line_length] + eStatus = eFrameworkunifiedStatusOK; + + // file duplicate + std::string bak_file_path = f_cfilepath; + bak_file_path.append(".valid.bak"); + int bak_fd = open(bak_file_path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0660); + if (bak_fd >= 0) { // LCOV_EXCL_BR_LINE 5: open's error case + if (write(bak_fd, &f_header, sizeof(f_header)) == sizeof(f_header)) { // LCOV_EXCL_BR_LINE 5: write's error case // NOLINT[whitespace/line_length] + if (write(bak_fd, buf, body_size) != static_cast(body_size)) { // LCOV_EXCL_BR_LINE 5: write's error case // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "write fail: %s", strerror(errno)); // LCOV_EXCL_LINE 5: write's error case // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "write fail: %s", strerror(errno)); // LCOV_EXCL_LINE 5: write's error case // NOLINT[whitespace/line_length] + } + close(bak_fd); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "open fail: %s", strerror(errno)); // LCOV_EXCL_LINE 5: open's error case // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "write fail: %s", strerror(errno)); // LCOV_EXCL_LINE 5: write's error case // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "lseek fail: %s", strerror(errno)); // LCOV_EXCL_LINE 5: lseek's error case // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "read fail: %s", strerror(errno)); // LCOV_EXCL_LINE 5: read's error case + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "lseek fail: %s", strerror(errno)); // LCOV_EXCL_LINE 5: lseek's error case + } + delete[] buf; + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Mem Allocation failure"); // LCOV_EXCL_LINE 5: new's error case + } + } else { + // 0byte file through + eStatus = eFrameworkunifiedStatusOK; + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "fstat fail: %s", strerror(errno)); // LCOV_EXCL_LINE 5: fstat's error case + } + + return eStatus; +} + +EFrameworkunifiedStatus CBinaryAccesser::CheckFileHeader(int f_infd) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusFail; + struct stat st; + + if (fstat(f_infd, &st) == 0) { // LCOV_EXCL_BR_LINE 5: fstat's error case + if (st.st_size > static_cast(sizeof(PersistFileHeder))) { // NOLINT (runtime/int) + size_t body_size = static_cast(st.st_size - sizeof(PersistFileHeder)); + char *buf = new(std::nothrow) char[body_size]; + if (buf != NULL) { // LCOV_EXCL_BR_LINE 5: new's error case + if (lseek(f_infd, sizeof(PersistFileHeder), SEEK_SET) == sizeof(PersistFileHeder)) { // LCOV_EXCL_BR_LINE 5: lseek's error case // NOLINT[whitespace/line_length] + if (read(f_infd, buf, body_size) == static_cast(body_size)) { + UI_32 crc32 = static_cast(CalcCRC(buf, static_cast(body_size))); + PersistFileHeder f_header; + if (lseek(f_infd, 0, SEEK_SET) == 0) { // LCOV_EXCL_BR_LINE 5: lseek's error case + if (read(f_infd, &f_header, sizeof(f_header)) == sizeof(f_header)) { // LCOV_EXCL_BR_LINE 5: read's error case // NOLINT[whitespace/line_length] + if (std::memcmp(&f_header.check_code, NPP_CHECK_CODE, sizeof(f_header.check_code)) == 0 + && f_header.crc == crc32) { + m_uiCurStrOffset = sizeof(f_header); + m_uiCurStrSize = static_cast(st.st_size); + eStatus = eFrameworkunifiedStatusOK; + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "file header fail: %02x %02x %02x %02x %#x:%#x", + f_header.check_code[0], f_header.check_code[1], + f_header.check_code[2], f_header.check_code[3], crc32, f_header.crc); + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "read fail: %s", strerror(errno)); // LCOV_EXCL_LINE 5: read's error case // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "lseek fail: %s", strerror(errno)); // LCOV_EXCL_LINE 5: lseek's error case // NOLINT[whitespace/line_length] + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "read fail: %s", strerror(errno)); + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "lseek fail: %s", strerror(errno)); // LCOV_EXCL_LINE 5: lseek's error case + } + delete[] buf; + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Mem Allocation failure"); // LCOV_EXCL_LINE 5: new's error case + } + } else { + // 0byte file through + eStatus = eFrameworkunifiedStatusOK; + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "fstat fail: %s", strerror(errno)); // LCOV_EXCL_LINE 5: fstat's error case + } + + return eStatus; +} + +EFrameworkunifiedStatus CBinaryAccesser::OpenBakFileForReading(int *f_infd, std::string f_cfilepath) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusFail; + std::string bak_file_path = f_cfilepath; + bak_file_path.append(".bak"); + + *f_infd = open(bak_file_path.c_str(), O_RDONLY); + if (*f_infd >= 0) { + struct stat st; + if (fstat(*f_infd, &st) == 0) { + // Error if bak file is 0byte + if (st.st_size > 0) { + if (eFrameworkunifiedStatusOK == CheckFileHeader(*f_infd)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "%s fail. bak file correct.", f_cfilepath.c_str()); + eStatus = eFrameworkunifiedStatusOK; + } else { + close(*f_infd); + *f_infd = -1; + } + } else { + close(*f_infd); + *f_infd = -1; + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "fstat fail: %s", strerror(errno)); + close(*f_infd); + *f_infd = -1; + } + } + + return eStatus; +} + +/* + * CRC-32C lookup table + * + * Polynomial 0x1EDC6F41 + */ +static const UI_32 crc32_lookup[4][256] = { // NOLINT (readability/naming) + { + }, + { + }, + { + }, + { + } +}; + +UI_32 CBinaryAccesser::CalcCRC(PVOID f_pdata, UI_32 f_size) { + UI_32 crc = 0xFFFFFFFF; + const UI_32 *current = (const UI_32 *)f_pdata; + + while (f_size >= 4) { + UI_32 one = *current++ ^ crc; + crc = crc32_lookup[0][(one >> 24) & 0xFF] ^ + crc32_lookup[1][(one >> 16) & 0xFF] ^ + crc32_lookup[2][(one >> 8) & 0xFF] ^ + crc32_lookup[3][one & 0xFF]; + f_size -= 4; + } + + const UI_8 *current_char = (const UI_8 *)current; + while (f_size-- > 0) { + crc = (crc >> 8) ^ crc32_lookup[0][(crc & 0xFF) ^ *current_char++]; + } + + return ~crc; +} diff --git a/service/native/notification_persistent_service/server/src/ns_npp_copy_worker.cpp b/service/native/notification_persistent_service/server/src/ns_npp_copy_worker.cpp new file mode 100755 index 0000000..4638a7d --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_copy_worker.cpp @@ -0,0 +1,1153 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file implements the CCopyWorker class. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include +#include + +// standard headers +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +// ns headers +#include "ns_npp_copy_worker.h" +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_fs_directory.h" +#include "ns_npp_persistence.h" +#include "ns_npp_threads.h" +#include "ns_npp.h" + +#ifdef AGL_STUB +#include +/*#include "PosixBasedOS001legacy_types.h"*/ +#include +#include +#endif + +#define NS_NPP_WRITESIZE1 4096 +#define NS_NPP_WRITESIZE2 32768 +#define NS_NPP_REMOVE_DIR_DELAY 100 // in ms +#define NS_NPP_FILEWRITE_DELAY 50 // in ms + +pthread_mutex_t g_mutworkerthread = PTHREAD_MUTEX_INITIALIZER; +pthread_mutex_t CCopyWorker::m_sAbortMutex = PTHREAD_MUTEX_INITIALIZER; +BOOL CCopyWorker::m_sbAbortCopy = FALSE; + +template EFrameworkunifiedStatus WorkerCallback(HANDLE hthread) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + C *l_pClass = static_cast(FrameworkunifiedGetThreadSpecificData(hthread)); + + if (l_pClass) { // LCOV_EXCL_BR_LINE 6: l_pClass can't be NULL + l_estatus = (l_pClass->*M)(hthread); + } + + return l_estatus; +} + +// Initialize static members +TMServiceTagCRC CCopyWorker::CCopyWorker::g_mservicetagcrc; +CMutex CCopyWorker::CCopyWorker::g_objmtxservicetag; + +static FrameworkunifiedProtocolCallbackHandler aServiceHandlers[] = { // NOLINT (readability/naming) // LCOV_EXCL_BR_LINE 11: unexpected branch + { CP_WRK_CMD_COPY, WorkerCallback }, + { CP_WRK_CMD_RESUME, WorkerCallback }, + { AR_CMD_ARCHIVE, WorkerCallback }, + { CMD_WRK_SHUTDOWN_REQ, WorkerCallback}, +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CCopyWorker +/// Constructor of CCopyWorker class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CCopyWorker::CCopyWorker() { + pthread_mutex_init(&m_sAbortMutex, NULL); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CCopyWorker +/// Destructor of CCopyWorker class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CCopyWorker::~CCopyWorker() { + pthread_mutex_destroy(&m_sAbortMutex); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// Abort +/// Method to abort worker thread. +//////////////////////////////////////////////////////////////////////////////////////////////////// +VOID CCopyWorker::Abort() { // LCOV_EXCL_START 8: not used + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + pthread_mutex_lock(&m_sAbortMutex); + m_sbAbortCopy = TRUE; + pthread_mutex_unlock(&m_sAbortMutex); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// InAbortState +/// Method to check for abort state. +//////////////////////////////////////////////////////////////////////////////////////////////////// +BOOL CCopyWorker::InAbortState() const { + BOOL l_bAbortStatus = FALSE; + pthread_mutex_lock(&m_sAbortMutex); + l_bAbortStatus = m_sbAbortCopy; + pthread_mutex_unlock(&m_sAbortMutex); + + return l_bAbortStatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SetCopyStatusToFailure +/// Method to set the copy status failure. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::SetCopyStatusToFailure(NSP_CopyStatusResponse &f_tcopystatusresponse, // LCOV_EXCL_START 8: not used // NOLINT[whitespace/line_length] + const ENPS_CopyWorkerFailures f_eworkerfailcmd) { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + f_tcopystatusresponse.m_bpersistencechk = FALSE; + f_tcopystatusresponse.m_ecopyfailures = f_eworkerfailcmd; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eFrameworkunifiedStatusFail; +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// OnWrkCmdCopy +/// Callback method on copy command. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::OnWrkCmdCopy(HANDLE hthread) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + NSP_CopyStatusResponse l_tCopyStatus = {}; + NSP_CopyInfoCmd l_tCopyInfo = {}; + UI_32 l_uiFileSize = 0; + UI_32 l_ui32FileCRC = 0; + PSTR l_cTmpStorageFile = NULL; + + if (NULL != hthread) { // LCOV_EXCL_BR_LINE 6: hthread can't be NULL + if (FrameworkunifiedGetMsgLength(hthread) == sizeof(l_tCopyInfo)) { // LCOV_EXCL_BR_LINE 200: the size of msg must be sizeof(NSP_CopyInfoCmd) // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(hthread, &l_tCopyInfo, sizeof(NSP_CopyInfoCmd), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + l_tCopyStatus.m_eloadtype = l_tCopyInfo.m_eloadtype; +#ifdef AGL_PosixBasedOS001LEGACY_USED + strlcpy(l_tCopyStatus.m_cpersistenttag, l_tCopyInfo.m_cpersistenttag, sizeof(l_tCopyStatus.m_cpersistenttag)); + strlcpy(l_tCopyStatus.m_crequesterappname, + l_tCopyInfo.m_crequesterappname, + sizeof(l_tCopyStatus.m_crequesterappname)); +#endif + + l_tCopyStatus.m_epersisttype = l_tCopyInfo.m_epersisttype; + + if (ENOTIFICATIONPERSISTENTSERVICECOMPRESSUSINGLIBZ == l_tCopyInfo.m_ecompressiontype) { // LCOV_EXCL_BR_LINE 6: l_tCopyInfo.m_ecompressiontype can't be ENOTIFICATIONPERSISTENTSERVICECOMPRESSUSINGLIBZ // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: l_tCopyInfo.m_ecompressiontype can't be ENOTIFICATIONPERSISTENTSERVICECOMPRESSUSINGLIBZ + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + CCopyWorker::CArchive *l_pCArchive = new(std::nothrow) CCopyWorker::CArchive(); + + if (NULL != l_pCArchive) { + // Start the folder archive or extract operation + if (eFrameworkunifiedStatusOK == (l_estatus = l_pCArchive->FileOperationUsingLibz(l_tCopyInfo, l_tCopyStatus))) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Compress/Decompress Successful"); + } else { + l_estatus = eFrameworkunifiedStatusFail; // Set the archive status to failure + } + delete l_pCArchive; + l_pCArchive = NULL; + } + // LCOV_EXCL_STOP + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Tag: %s SourceFile: %s DestFile: %s", + l_tCopyInfo.m_cpersistenttag != 0 ? l_tCopyInfo.m_cpersistenttag : NULL, + l_tCopyInfo.m_csourcepath != 0 ? l_tCopyInfo.m_csourcepath : NULL, + l_tCopyInfo.m_cdestinationpath != 0 ? l_tCopyInfo.m_cdestinationpath : NULL); + + if (LOADTYPE_RELEASE == l_tCopyStatus.m_eloadtype) { + // if release, source file needs to check whether it's changed or not + l_cTmpStorageFile = l_tCopyInfo.m_csourcepath; + } else if (LOADTYPE_LOAD == l_tCopyStatus.m_eloadtype) { // LCOV_EXCL_BR_LINE 6: m_eloadtype must be LOADTYPE_RELEASE or LOADTYPE_LOAD // NOLINT[whitespace/line_length] + // if load, dest file needs to check whether it's changed or not + l_cTmpStorageFile = l_tCopyInfo.m_cdestinationpath; + + // check if file on temporary location exists, then no need to load from persistent memory + if (0 == access(l_tCopyInfo.m_cdestinationpath, F_OK)) { // LCOV_EXCL_BR_LINE 5: access's error case + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "File to load::%s for source::%s " + "is already present on path:: %s.", + l_tCopyInfo.m_cpersistenttag != 0 ? l_tCopyInfo.m_cpersistenttag : NULL, + l_tCopyStatus.m_crequesterappname != 0 ? l_tCopyStatus.m_crequesterappname : NULL, + l_tCopyInfo.m_cdestinationpath != 0 ? l_tCopyInfo.m_cdestinationpath : NULL); + l_estatus = eFrameworkunifiedStatusFileLoadSuccess; + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + // let l_cTmpStorageFile be NULL. + } + + if (eFrameworkunifiedStatusFileLoadSuccess == l_estatus) { + l_estatus = eFrameworkunifiedStatusOK; + } else { + if (NULL != l_cTmpStorageFile) { // LCOV_EXCL_BR_LINE 6: l_cTmpStorageFile can't be NULL + if (!VerifyWithStoredCRC(l_tCopyStatus.m_crequesterappname, + l_tCopyStatus.m_cpersistenttag, + l_cTmpStorageFile, + l_ui32FileCRC)) { // l_ui32FileCRC: out param + // Check if file release and CRC verification is enabled + if ((LOADTYPE_RELEASE == l_tCopyStatus.m_eloadtype) && (CNSNPP::m_siCRCCheckCount > 0)) { // LCOV_EXCL_BR_LINE 200: cannot test code // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 200: cannot test code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = TryFileCopyWithCRCCheck(l_tCopyInfo.m_csourcepath, + l_tCopyInfo.m_cdestinationpath, + CNSNPP::m_siCRCCheckCount); + // LCOV_EXCL_STOP + } else { + if (LOADTYPE_RELEASE == l_tCopyStatus.m_eloadtype) { + l_estatus = CopyFile(l_tCopyInfo.m_csourcepath, + l_tCopyInfo.m_cdestinationpath, + l_uiFileSize, + TRUE); + } else { + l_estatus = CopyFile(l_tCopyInfo.m_csourcepath, + l_tCopyInfo.m_cdestinationpath, + l_uiFileSize, + FALSE); + } + } + if (eFrameworkunifiedStatusOK == l_estatus) { + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO3, __FUNCTION__, "Bytes written:%d file=%s", + l_uiFileSize, l_tCopyInfo.m_cdestinationpath != 0 ? l_tCopyInfo.m_cdestinationpath : NULL); + if (0 == l_ui32FileCRC) { + if (eFrameworkunifiedStatusOK != CalculateCRC32(l_cTmpStorageFile, l_ui32FileCRC)) { // LCOV_EXCL_BR_LINE 200: CalculateCRC32() return ok // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 200: CalculateCRC32() return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Warn: getting crc. File:%s, crc:%d", + l_cTmpStorageFile, l_ui32FileCRC); + // LCOV_EXCL_STOP + } + } + UpdateTagCRC(l_tCopyStatus.m_crequesterappname, l_tCopyInfo.m_cpersistenttag, l_ui32FileCRC); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FileCopy Error, status : 0x%x", l_estatus); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, + "File %s not changed. No copy done. Load type:%d. Tag:%s for Requester:%s.", + l_cTmpStorageFile, + l_tCopyStatus.m_eloadtype, + l_tCopyStatus.m_cpersistenttag != 0 ? l_tCopyStatus.m_cpersistenttag : NULL, + l_tCopyStatus.m_crequesterappname != 0 ? l_tCopyStatus.m_crequesterappname : NULL); + } + } else { + // LCOV_EXCL_START 6: l_cTmpStorageFile can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unknown load type:%d, for tag:%s", + l_tCopyStatus.m_eloadtype, + l_tCopyStatus.m_cpersistenttag != 0 ? l_tCopyStatus.m_cpersistenttag : NULL); + // LCOV_EXCL_STOP + } + } + } + + if (eFrameworkunifiedStatusOK != l_estatus) { + l_tCopyStatus.m_bpersistencechk = FALSE; + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "COPY_FAILED_ID sending parent message. Tag:%s for Requester:%s.", + l_tCopyStatus.m_cpersistenttag != 0 ? l_tCopyStatus.m_cpersistenttag : NULL, + l_tCopyStatus.m_crequesterappname != 0 ? l_tCopyStatus.m_crequesterappname : NULL); + + FrameworkunifiedSendParent(hthread, CP_WRK_NTFY, sizeof(NSP_CopyStatusResponse), &l_tCopyStatus); + } else { + l_tCopyStatus.m_bpersistencechk = TRUE; + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "COPY_COMPLETE_ID sending parent message. Tag:%s for Requester:%s.", + l_tCopyStatus.m_cpersistenttag != 0 ? l_tCopyStatus.m_cpersistenttag : NULL, + l_tCopyStatus.m_crequesterappname != 0 ? l_tCopyStatus.m_crequesterappname : NULL); + + FrameworkunifiedSendParent(hthread, CP_WRK_NTFY, sizeof(NSP_CopyStatusResponse), &l_tCopyStatus); + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error:FrameworkunifiedGetMsgDataOfSize returned:%d", l_estatus); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + } else { + // LCOV_EXCL_START 200: the size of msg must be sizeof(NSP_CopyInfoCmd) + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error:MsgLength: Expected:%ld, Received:%d.", + static_cast(sizeof(l_tCopyInfo)), FrameworkunifiedGetMsgLength(hthread)); // NOLINT (runtime/int) + // LCOV_EXCL_STOP + } + l_estatus = SendAck(hthread, CP_WRK_CMD_COPY); + } else { + // LCOV_EXCL_START 6: hthread can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Thread App Handle Null"); + l_estatus = eFrameworkunifiedStatusInvldHandle; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// GetCopyBufSize +/// Get the proper buffer size. +//////////////////////////////////////////////////////////////////////////////////////////////// +SI_32 CCopyWorker::GetCopyBufSize(SI_32 f_si32openfd, UI_32 &f_ui32filesize) { + UI_32 l_ui32BufSize = NS_NPP_WRITESIZE1; + // to get the size of file + struct stat l_tSrcFstat = {}; + + if (-1 == fstat(f_si32openfd , &l_tSrcFstat)) { // LCOV_EXCL_BR_LINE 5: fstat's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "fstat failure, errno:%d", errno); // LCOV_EXCL_LINE 5: fstat's error case + } else { + f_ui32filesize = static_cast(l_tSrcFstat.st_size); // set out param + if (l_tSrcFstat.st_size < NS_NPP_WRITESIZE1) { + l_ui32BufSize = NS_NPP_WRITESIZE1; + } else { + l_ui32BufSize = NS_NPP_WRITESIZE2; + } + } + return l_ui32BufSize; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// CopyFile +/// Copy the content of source file f_csrcpath to destination file f_cdestpath +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::CopyFile(PCSTR f_csrcpath, PCSTR f_cdestpath, UI_32 &f_uiNS_NPP_WRITESIZE, BOOL btmpfile) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // declare variables + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + SI_32 l_iSourceFileFd = -1; // file descriptor of source file + SI_32 l_iDestFileFd = -1; // file descriptor of destination file + PSTR l_cWriteBuffer = NULL; + SI_32 l_si32BufSize = NS_NPP_WRITESIZE1; + size_t l_iReadBuffLength = 0; // size of data read from source file + UI_32 l_ui32SrcFileSize = 0; + std::string l_cTempDestPath; // temporary file path + if (btmpfile == FALSE) { + l_cTempDestPath = f_cdestpath; + } else { + l_cTempDestPath = CPersistence::GetStoragePath(); // LCOV_EXCL_BR_LINE 11: unexpected branch + if (l_cTempDestPath.length() > 0) { // LCOV_EXCL_BR_LINE 6: l_cTempDestPath.length() is bigger than 0 + l_cTempDestPath.append(RELEASETEMP_DIR); // LCOV_EXCL_BR_LINE 11: unexpected branch + // create the destination folder path if does not exists + if (!CFSDirectory::DoesDirecotryExist(l_cTempDestPath)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "%s DOESN'T exist, Creating...", l_cTempDestPath.c_str()); + if (eFrameworkunifiedStatusOK != (l_estatus = CFSDirectory::CreateDirectory(l_cTempDestPath))) { // LCOV_EXCL_BR_LINE 200: CreateDirectory() is eFrameworkunifiedStatusOK // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 200: CreateDirectory() is eFrameworkunifiedStatusOK + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Failed to create %s, errno:%d", l_cTempDestPath.c_str(), errno); + return l_estatus; + // LCOV_EXCL_STOP + } + } + l_cTempDestPath.append(RELEASETEMP_FILENAME); + + } else { + // LCOV_EXCL_START 6: l_cTempDestPath.length() is bigger than 0 + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_cTempDestPath.length():%ld", static_cast(l_cTempDestPath.length())); // NOLINT (runtime/int) + return eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + } + // get the destination folder path from full file path + std::string l_cOutDirPath(f_cdestpath); + size_t l_ifound = l_cOutDirPath.rfind("/"); + l_cOutDirPath = l_cOutDirPath.substr(0, l_ifound); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Full Path for persistence %s.", f_cdestpath); + + // create the destination folder path if does not exists + if (!CFSDirectory::DoesDirecotryExist(l_cOutDirPath)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "%s DOESN'T exist, Creating...", l_cOutDirPath.c_str()); + + if (eFrameworkunifiedStatusOK != (l_estatus = CFSDirectory::CreateDirectory(l_cOutDirPath))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Failed to create %s, errno:%d", l_cOutDirPath.c_str(), errno); + return eFrameworkunifiedStatusFail; + } + } + + // open source file + if (-1 == (l_iSourceFileFd = open(f_csrcpath, O_RDONLY, S_IRUSR))) { // LCOV_EXCL_BR_LINE 5: open's error case + // LCOV_EXCL_START 5: open's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Warning :: CP_WRK_FAILURE_SRC_NOT_FND, errno:%d", errno); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } else { + // open the destination file for writing or create if does not exists + if (-1 == (l_iDestFileFd = open(l_cTempDestPath.c_str(), O_WRONLY | O_CREAT | O_TRUNC, // LCOV_EXCL_BR_LINE 5: open's error case // NOLINT[whitespace/line_length] + S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH))) { + // LCOV_EXCL_START 5: open's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "CP_WRK_FAILURE_DST_CREATE, errno:%d", errno); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } else { + l_si32BufSize = GetCopyBufSize(l_iSourceFileFd, l_ui32SrcFileSize); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Src file:%s, size:%d", f_csrcpath, l_ui32SrcFileSize); + l_cWriteBuffer = (PSTR) std::malloc(l_si32BufSize); + f_uiNS_NPP_WRITESIZE = 0; + + if (NULL != l_cWriteBuffer) { // LCOV_EXCL_BR_LINE 5: malloc's error case +#ifdef AGL_STUB + while (1) { + std::memset(l_cWriteBuffer, 0, l_si32BufSize); + l_iReadBuffLength = read(l_iSourceFileFd, l_cWriteBuffer, l_si32BufSize); + if (0 == l_iReadBuffLength) { + break; + } else if (0 < l_iReadBuffLength) { // LCOV_EXCL_BR_LINE 5: read's error case + f_uiNS_NPP_WRITESIZE += static_cast(l_iReadBuffLength); + + if (-1 == write(l_iDestFileFd, l_cWriteBuffer, l_iReadBuffLength)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "CP_WRK_FAILURE_WRITE_ERROR_CP, errno:%d", errno); + l_estatus = eFrameworkunifiedStatusFail; + } + + if (InAbortState()) { // LCOV_EXCL_START 200: the state can't be aborted + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "CP_WRK_FAILURE_ABORT_DURING_CP"); + l_estatus = eFrameworkunifiedStatusFail; + } + // LCOV_EXCL_STOP + } else { + // LCOV_EXCL_START 5: read's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error reading from source file, errno:%d", errno); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + + if (eFrameworkunifiedStatusOK != l_estatus) { + break; + } + } +#else + while (!eof(l_iSourceFileFd)) { + std::memset(l_cWriteBuffer, 0, l_si32BufSize); + if (-1 != (l_iReadBuffLength = read(l_iSourceFileFd, l_cWriteBuffer, l_si32BufSize))) { + f_uiNS_NPP_WRITESIZE += static_cast(l_iReadBuffLength); + + if (-1 == write(l_iDestFileFd, l_cWriteBuffer, l_iReadBuffLength)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "CP_WRK_FAILURE_WRITE_ERROR_CP, errno:%d", errno); + l_estatus = eFrameworkunifiedStatusFail; + } + + if (InAbortState()) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "CP_WRK_FAILURE_ABORT_DURING_CP"); + l_estatus = eFrameworkunifiedStatusFail; + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error reading from source file, errno:%d", errno); + l_estatus = eFrameworkunifiedStatusFail; + } + + if (eFrameworkunifiedStatusOK != l_estatus) { + break; + } + } +#endif + + free(l_cWriteBuffer); + l_cWriteBuffer = NULL; + } else { + // LCOV_EXCL_START 5: malloc's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Mem alloc error for l_cWriteBuffer"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + + close(l_iDestFileFd); + + if (eFrameworkunifiedStatusOK == l_estatus) { + if (btmpfile == TRUE) { + if (0 != rename(l_cTempDestPath.c_str(), f_cdestpath)) { // LCOV_EXCL_START 5: rename's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, + "Error renaming file %s to %s, errno: %d", l_cTempDestPath.c_str(), f_cdestpath, + errno); + } + // LCOV_EXCL_STOP + } + } else { + // remove the source file after successful copy + if (0 != remove(l_cTempDestPath.c_str())) { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Temporary file not deleted::%s, errno:%d", l_cTempDestPath.c_str(), errno); + } + } + } + + close(l_iSourceFileFd); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// OnWrkCmdResume +/// Callback on resume worker thread command +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::OnWrkCmdResume(HANDLE hthread) { // LCOV_EXCL_START 8: not used + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (hthread) { + pthread_mutex_lock(&m_sAbortMutex); + m_sbAbortCopy = FALSE; + pthread_mutex_unlock(&m_sAbortMutex); + l_estatus = SendAck(hthread, CP_WRK_CMD_RESUME); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Thread App Handle Null."); + l_estatus = eFrameworkunifiedStatusInvldHandle; + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// OnWrkCmdStart +/// Callback method on start worker thread command. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::OnWrkCmdStart(HANDLE hthread) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (hthread) { // LCOV_EXCL_BR_LINE 6:hthread can't be NULL + l_estatus = SendAck(hthread, CP_WRK_CMD_START); + } else { + // LCOV_EXCL_START 6:hthread can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Thread App Handle Null."); + l_estatus = eFrameworkunifiedStatusInvldHandle; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// OnWrkCmdStop +/// Callback method on stop worker thread command. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::OnWrkCmdStop(HANDLE hthread) { // LCOV_EXCL_START 200: can't test + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (hthread) { + l_estatus = SendAck(hthread, CP_WRK_CMD_STOP); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Thread App Handle Null."); + l_estatus = eFrameworkunifiedStatusInvldHandle; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// OnCmdShutdownRequest +/// Callback method for shutdown request command. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::OnCmdShutdownRequest(HANDLE hthread) { // LCOV_EXCL_START 8: not used + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + if (hthread) { + NSP_CopyShutdownAck l_tCopyShutdownAck = {}; + if (FrameworkunifiedGetMsgLength(hthread) == sizeof(l_tCopyShutdownAck)) { + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(hthread, &l_tCopyShutdownAck, sizeof(NSP_CopyShutdownAck), + eSMRRelease))) { + FrameworkunifiedSendParent(hthread, CMD_WRK_SHUTDOWN_ACK, sizeof(NSP_CopyShutdown), &l_tCopyShutdownAck); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error:FrameworkunifiedGetMsgDataOfSize returned:%d", l_estatus); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error:MsgLength: Expected:%ld, Received:%d.", + static_cast(sizeof(l_tCopyShutdownAck)), FrameworkunifiedGetMsgLength(hthread)); // NOLINT (runtime/int) + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Thread App Handle Null."); + l_estatus = eFrameworkunifiedStatusInvldHandle; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SendAck +/// Method to send ack to the parent thread +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::SendAck(HANDLE hthread, const ENSP_CopyWorkerProtocol &f_eworkercmd) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (hthread) { // LCOV_EXCL_BR_LINE 6: hthread can't be NULL + NSP_CopyAckMsg l_tCopyAckMs = {}; + l_tCopyAckMs.m_eworkerprotocol = f_eworkercmd; + l_estatus = FrameworkunifiedSendParent(hthread, CP_WRK_ACK_CMD_COMPLETE, sizeof(l_tCopyAckMs), &l_tCopyAckMs); + } else { + // LCOV_EXCL_START 6: hthread can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Thread App Handle Null."); + l_estatus = eFrameworkunifiedStatusInvldHandle; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// OnWrkCmdArchive +/// Callback method on archive command +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::OnWrkCmdArchive(HANDLE f_hThread) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // Archive response struct + NSP_CopyStatusResponse l_tArchiveStatusResponse; + + if (f_hThread) { // LCOV_EXCL_BR_LINE 6: f_hThread can't be NULL + // Archive info struct + NSP_CopyInfoCmd l_tArchiveInfo = {}; + + if (FrameworkunifiedGetMsgLength(f_hThread) == sizeof(l_tArchiveInfo)) { // LCOV_EXCL_BR_LINE 4: NSFW error case + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(f_hThread, &l_tArchiveInfo, sizeof(NSP_CopyInfoCmd), // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + eSMRRelease))) { + // Copy archive status response + l_tArchiveStatusResponse.m_eloadtype = l_tArchiveInfo.m_eloadtype; + l_tArchiveStatusResponse.m_epersisttype = l_tArchiveInfo.m_epersisttype; + std::strncpy(l_tArchiveStatusResponse.m_cpersistenttag, l_tArchiveInfo.m_cpersistenttag, (MAX_PATH_LENGTH - 1)); + std::strncpy(l_tArchiveStatusResponse.m_crequesterappname, + l_tArchiveInfo.m_crequesterappname, (MAX_PATH_LENGTH - 1)); + + CCopyWorker::CArchive *l_pCArchive = new CCopyWorker::CArchive(); + + // Start the folder archive or extract operation + if (eFrameworkunifiedStatusOK == (l_estatus = l_pCArchive->Archive(l_tArchiveInfo, l_tArchiveStatusResponse))) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Archive/Extract Successful!"); + } else { + // Set the archive status to failure + l_estatus = eFrameworkunifiedStatusFail; + } + if (NULL != l_pCArchive) { // LCOV_EXCL_BR_LINE 5: l_pCArchive can't be null + delete l_pCArchive; + l_pCArchive = NULL; + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error:FrameworkunifiedGetMsgDataOfSize returned:%d", l_estatus); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error:MsgLength: Expected:%ld, Received:%d.", + static_cast(sizeof(l_tArchiveInfo)), FrameworkunifiedGetMsgLength(f_hThread)); // NOLINT (runtime/int) + // LCOV_EXCL_STOP + } + + if (eFrameworkunifiedStatusOK != l_estatus) { + l_tArchiveStatusResponse.m_bpersistencechk = FALSE; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Archive/Extract fail.Sending parent message!"); + } else { + l_tArchiveStatusResponse.m_bpersistencechk = TRUE; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Archive/Extract success.Sending parent message!"); + } + + FrameworkunifiedSendParent(f_hThread, CP_WRK_NTFY, sizeof(NSP_CopyStatusResponse), &l_tArchiveStatusResponse); + } else { + // LCOV_EXCL_START 6: f_hThread can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Thread Application Handle NULL"); + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NSPCopyWorkerOnStart +/// Callback method on start of worker thread +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NSPCopyWorkerOnStart(HANDLE hthread) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (hthread) { // LCOV_EXCL_BR_LINE 6: hthread can't be NULL + pthread_mutex_lock(&g_mutworkerthread); + + // Note: this variable is made static just to ignore the resource leak showing in coverity analysis + static CCopyWorker *l_pccopyworker = NULL; + + l_pccopyworker = new(std::nothrow) CCopyWorker; // LCOV_EXCL_BR_LINE 11: unexpected branch + + if (NULL != l_pccopyworker) { // LCOV_EXCL_BR_LINE 5: l_pccopyworker can't be NULL + if (eFrameworkunifiedStatusOK == (l_estatus = l_pccopyworker->OnWrkCmdStart(hthread))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + l_estatus = FrameworkunifiedSetThreadSpecificData(hthread, l_pccopyworker); + + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 4: NSFW error case + l_estatus = FrameworkunifiedAttachCallbacksToDispatcher( + hthread, AppName, aServiceHandlers, static_cast(_countof(aServiceHandlers))); + + if (0 == std::strcmp(NS_NPP_WRITE_THREAD_NAME, FrameworkunifiedGetAppName(hthread))) { + l_estatus = FrameworkunifiedAttachCallbackToDispatcher(hthread, AppName, + CMD_DELETE_OLD_DATA, NPServiceOnDeleteOldDataCmd); + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + delete l_pccopyworker; + l_pccopyworker = NULL; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + delete l_pccopyworker; + l_pccopyworker = NULL; + + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Thread Start failed."); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 5: l_pccopyworker can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Worker Object Null."); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + pthread_mutex_unlock(&g_mutworkerthread); + } else { + // LCOV_EXCL_START 6: hthread can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Thread App Handle Null."); + l_estatus = eFrameworkunifiedStatusInvldHandle; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NSPCopyWorkerOnStop +/// Callback method on stop of worker thread +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NSPCopyWorkerOnStop(HANDLE hthread) { // LCOV_EXCL_START 200: can't test + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (NULL != hthread) { + pthread_mutex_lock(&g_mutworkerthread); + CCopyWorker *l_pccopyworker = static_cast(FrameworkunifiedGetThreadSpecificData(hthread)); + + if (NULL != l_pccopyworker) { + l_pccopyworker->OnWrkCmdStop(hthread); + + delete l_pccopyworker; + l_pccopyworker = NULL; + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Worker Object Null"); + l_estatus = eFrameworkunifiedStatusNullPointer; + } + + if (eFrameworkunifiedStatusOK != (l_estatus = FrameworkunifiedSetThreadSpecificData(hthread, NULL))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedSetThreadSpecificData Error, status=%d", l_estatus); + } + + PCSTR l_cservice = FrameworkunifiedGetAppName(hthread); + if (NULL != l_cservice) { + if (eFrameworkunifiedStatusOK != (l_estatus = FrameworkunifiedDetachServiceFromDispatcher(hthread, l_cservice))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error Detaching service %s from dispatcher, status=%d", l_cservice, l_estatus); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedGetAppName returned NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + } + + pthread_mutex_unlock(&g_mutworkerthread); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Thread App Handle Null."); + l_estatus = eFrameworkunifiedStatusInvldHandle; + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + + return l_estatus; +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPServiceOnDeleteOldDataCmd +/// This callback is used to delete the data which was requested to be deleted during +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPServiceOnDeleteOldDataCmd(HANDLE f_happ) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + SI_32 l_ithreadcreate = 0; + pthread_attr_t l_tattr; + struct sched_param l_tschedparam = {}; + + // thread id + pthread_t childthread = 0; + + if (EOK == pthread_attr_init(&l_tattr)) { // LCOV_EXCL_BR_LINE 11:except,C++ STL + // detach the thread from parent thread + if (EOK != pthread_attr_setdetachstate(&l_tattr, PTHREAD_CREATE_DETACHED)) { // LCOV_EXCL_BR_LINE 11:except,C++ STL + // LCOV_EXCL_START 11:except,C++ STL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error setting detach state attribute for thread %s", NS_NPP_DATA_RESET_THREAD_NAME); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 200: l_estatus must be eFrameworkunifiedStatusOK + // set the schedule property of thread + if (EOK != pthread_attr_setinheritsched(&l_tattr, PTHREAD_EXPLICIT_SCHED)) { // LCOV_EXCL_BR_LINE 5:except,C++ STL // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 5:except,C++ STL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error setting inherit schedule attribute for thread %s", NS_NPP_DATA_RESET_THREAD_NAME); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + } + + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 200: l_estatus must be eFrameworkunifiedStatusOK + if (EOK != pthread_attr_getschedparam(&l_tattr, &l_tschedparam)) { // LCOV_EXCL_BR_LINE 5:except,C++ STL + // LCOV_EXCL_START 5:except,C++ STL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error getting schedule param attribute for thread %s", NS_NPP_DATA_RESET_THREAD_NAME); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + } + + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 200: l_estatus must be eFrameworkunifiedStatusOK + // set the schedule priority of thread + l_tschedparam.sched_priority = NS_NPP_DATA_RESET_THREAD_PRIO; + if (EOK != pthread_attr_setschedparam(&l_tattr, &l_tschedparam)) { // LCOV_EXCL_BR_LINE 5:except,C++ STL + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error setting schedule param attribute for thread %s", NS_NPP_DATA_RESET_THREAD_NAME); + l_estatus = eFrameworkunifiedStatusFail; + } + } + + if (eFrameworkunifiedStatusOK == l_estatus) { + // start the child thread + if (EOK == (l_ithreadcreate = pthread_create(&childthread, &l_tattr, NSPDataResetThreadCallback, NULL))) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + "Thread id %ld created, name=%s, prio=%d", childthread, NS_NPP_DATA_RESET_THREAD_NAME, + NS_NPP_DATA_RESET_THREAD_PRIO); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "pthread_create failed for %s, error = %d", NS_NPP_DATA_RESET_THREAD_NAME, + l_ithreadcreate); + } + } + + // release the thread attribute object + pthread_attr_destroy(&l_tattr); + } else { + // LCOV_EXCL_START 11:except,C++ STL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to initialize attribute for thread %s", NS_NPP_DATA_RESET_THREAD_NAME); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NSPDataResetThreadCallback +/// Callback of data reset thread. +/////////////////////////////////////////////////////////////////////////////////////////// +PVOID NSPDataResetThreadCallback(PVOID f_parg) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + std::string f_csourcepath = ""; + std::string f_ctargetpath = ""; + std::string l_ctargetdir = ""; + + DIR *l_pdir = NULL; + struct dirent *l_pdirent = NULL; + + // set the name of thread + if (EOK == pthread_setname_np(0, NS_NPP_DATA_RESET_THREAD_NAME)) { // LCOV_EXCL_BR_LINE 5:pthread_setname_np's error case // NOLINT[whitespace/line_length] +#ifdef AGL_STUB + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Name of thread id %ld set to %s", + syscall(__NR_gettid), NS_NPP_DATA_RESET_THREAD_NAME); +#else + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Name of thread id %d set to %s", gettid(), NS_NPP_DATA_RESET_THREAD_NAME); +#endif + } else { + // LCOV_EXCL_START 5:pthread_setname_np's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert +#ifdef AGL_STUB + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Error setting name %s for thread-id %ld", NS_NPP_DATA_RESET_THREAD_NAME, + syscall(__NR_gettid)); +#else + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Error setting name %s for thread-id %d", NS_NPP_DATA_RESET_THREAD_NAME, gettid()); +#endif + // LCOV_EXCL_STOP + } + + f_csourcepath = CPersistence::GetStoragePath(); + l_pdir = opendir(f_csourcepath.c_str()); + + if (NULL != l_pdir) { // LCOV_EXCL_BR_LINE 5:opendir's error case + if ('/' != f_csourcepath[f_csourcepath.length() - 1]) { // LCOV_EXCL_BR_LINE 200: there must be '/' in f_csourcepath // NOLINT[whitespace/line_length] + f_csourcepath.append("/"); + } + + /* + * Old Persistent data folders which needs to be deleted are renamed with the orignal folder name + * followed by underscore and date and time. + */ + std::string l_colduserdata = USERDATA; + l_colduserdata.append("_"); + + std::string l_coldfactorydata = FACTORYDATA; + l_coldfactorydata.append("_"); + + std::string l_coldfactorycustomerdata = FACTORYCUSTOMERDATA; + l_coldfactorycustomerdata.append("_"); + + std::string l_colddealerdata = DEALERDATA; + l_colddealerdata.append("_"); + + while (NULL != (l_pdirent = readdir(l_pdir))) { + l_ctargetdir = l_pdirent->d_name; + + if (0 == l_ctargetdir.find(l_colduserdata) || + 0 == l_ctargetdir.find(l_coldfactorydata) || + 0 == l_ctargetdir.find(l_coldfactorycustomerdata) || + 0 == l_ctargetdir.find(l_colddealerdata)) { + f_ctargetpath.assign(f_csourcepath); + f_ctargetpath.append(l_ctargetdir); + + if (!CFSDirectory::RemoveDirectory(f_ctargetpath, NS_NPP_REMOVE_DIR_DELAY)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to delete directory :: %s", f_ctargetpath.c_str()); + } + } + } + closedir(l_pdir); // close the directory + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Directory does not exists :: %s", f_csourcepath.c_str()); // LCOV_EXCL_LINE 5:opendir's error case // NOLINT[whitespace/line_length] + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return NULL; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// VerifyWithStoredCRC +/// Check if crc of the file passed matches with existing crc of a file +/////////////////////////////////////////////////////////////////////////////////////////// +BOOL CCopyWorker::VerifyWithStoredCRC(PCSTR f_crequesterappname, PCSTR f_cpersistenttag, PCSTR f_cFile, + UI_32 &f_ui32crc) { + UI_32 l_ui32StoredCrc = 0; + BOOL l_bRet = FALSE; + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + TMServiceTagCRC::iterator l_itServiceTag; + TMTagCRC::iterator l_itTagCRC; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + f_ui32crc = 0; // initialize with default + + if ((NULL != f_crequesterappname) && (NULL != f_cpersistenttag) && (NULL != f_cFile)) { // LCOV_EXCL_BR_LINE 6: f_crequesterappname, f_cpersistenttag, f_cFile can't be null // NOLINT[whitespace/line_length] + // Get the existing crc of a file from the map + CCopyWorker::g_objmtxservicetag.ReadLock(); + l_itServiceTag = CCopyWorker::g_mservicetagcrc.find(f_crequesterappname); + if (l_itServiceTag != CCopyWorker::g_mservicetagcrc.end()) { + l_itTagCRC = (l_itServiceTag->second).find(f_cpersistenttag); + if (l_itTagCRC != (l_itServiceTag->second).end()) { + l_ui32StoredCrc = (l_itTagCRC->second); + l_estatus = eFrameworkunifiedStatusOK; + } else { + // Do nothing. + } + } else { + // Do nothing. + } + CCopyWorker::g_objmtxservicetag.Unlock(); + + if (eFrameworkunifiedStatusOK == l_estatus) { + // get the crc of a file + l_estatus = CalculateCRC32(f_cFile, f_ui32crc); + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 200: CalculateCRC32() return ok + if (f_ui32crc == l_ui32StoredCrc) { + l_bRet = TRUE; + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "CRC matched. crc:%u", l_ui32StoredCrc); + } else { + // Do nothing. Return value already set. + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "CRC different. stored:%u, new:%u", + l_ui32StoredCrc, f_ui32crc); + } + } else { + // LCOV_EXCL_START: CalculateCRC32() return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Warn: getting crc:file:%s, status:%d, errno:%d", + f_cFile, l_estatus, errno); + // LCOV_EXCL_STOP + } + } else { + // Do nothing. Return value already set. + } + } else { + // LCOV_EXCL_START 6: f_crequesterappname, f_cpersistenttag, f_cFile can't be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid param::f_crequesterappname:%p, f_cpersistenttag:%p, f_cFile:%p", + f_crequesterappname, f_cpersistenttag, f_cFile); + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_bRet; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// UpdateTagCRC +/// Update the internal map with new crc +/////////////////////////////////////////////////////////////////////////////////////////// +VOID CCopyWorker::UpdateTagCRC(PCSTR f_crequesterappname, PCSTR f_cpersistenttag, UI_32 f_ui32crc) { + TMServiceTagCRC::iterator l_itServiceTag; + TMTagCRC::iterator l_itTagCRC; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CCopyWorker::g_objmtxservicetag.ReadLock(); + l_itServiceTag = CCopyWorker::g_mservicetagcrc.find(f_crequesterappname); + if (l_itServiceTag != CCopyWorker::g_mservicetagcrc.end()) { + l_itTagCRC = (l_itServiceTag->second).find(f_cpersistenttag); + if (l_itTagCRC != (l_itServiceTag->second).end()) { + l_itTagCRC->second = f_ui32crc; + } else { + (l_itServiceTag->second).insert(std::make_pair(f_cpersistenttag, f_ui32crc)); + } + } else { + TMTagCRC l_mTagCRC; + l_mTagCRC.insert(std::make_pair(f_cpersistenttag, f_ui32crc)); + CCopyWorker::g_mservicetagcrc.insert(std::make_pair(f_crequesterappname, l_mTagCRC)); + } + CCopyWorker::g_objmtxservicetag.Unlock(); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// TryFileCopyWithCRCCheck +/// Try file copy with CRC validation +/////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CCopyWorker::TryFileCopyWithCRCCheck(PCSTR f_csource, PCSTR f_cdest, UI_32 f_ui32checkcount) { // LCOV_EXCL_START 200: cannot test code // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + UI_32 l_uiSrcFileCrc = 0; + UI_32 l_uiDestFileCrc = 0; + UI_32 l_uiFileSize = 0; + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + for (UI_16 l_uiCrcCnt = 1; l_uiCrcCnt <= CNSNPP::m_siCRCCheckCount; l_uiCrcCnt++) { + l_uiSrcFileCrc = 0; + l_uiDestFileCrc = 0; + l_uiFileSize = 0; + + l_estatus = CopyFile(f_csource, f_cdest, l_uiFileSize, TRUE); + if (eFrameworkunifiedStatusOK == l_estatus) { + // calculate crc of file in temp memory(RAM) + l_estatus = CalculateCRC32(f_csource, l_uiSrcFileCrc); + if (eFrameworkunifiedStatusOK == l_estatus) { + // calculate crc of file stored in persistent memory + l_estatus = CalculateCRC32(f_cdest, l_uiDestFileCrc); + if (eFrameworkunifiedStatusOK == l_estatus) { + if (l_uiSrcFileCrc == l_uiDestFileCrc) { // if checksum matches for both the files + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "CRC Checksum matches for file:%s :: 0x%x", f_csource, l_uiSrcFileCrc); + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO3, __FUNCTION__, "Bytes written:%d file=%s", + l_uiFileSize, f_cdest); + break; + } else { // else delete the file from target + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "CRC doesn't match for src:%s::0x%x and dest:%s::0x%x, CRC cnt=%d", + f_csource, l_uiSrcFileCrc, f_cdest, l_uiDestFileCrc, l_uiCrcCnt); + // if the checksum does not matches even for the last time, do not delete the file from target + if (l_uiCrcCnt < (CNSNPP::m_siCRCCheckCount)) { + if (0 != remove(f_cdest)) { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Error deleting file:%s, errno:%d", f_cdest, errno); + } + } + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error Calculating Checksum for DestFile:%s", + f_cdest != 0 ? f_cdest : NULL); + l_estatus = eFrameworkunifiedStatusFail; + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error Calculating Checksum for SrcFile:%s", + f_csource != 0 ? f_csource : NULL); + l_estatus = eFrameworkunifiedStatusFail; + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FileCopy Error:%d", l_estatus); + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} +// LCOV_EXCL_STOP diff --git a/service/native/notification_persistent_service/server/src/ns_npp_fs_directory.cpp b/service/native/notification_persistent_service/server/src/ns_npp_fs_directory.cpp new file mode 100755 index 0000000..8f4f98a --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_fs_directory.cpp @@ -0,0 +1,232 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains the implementation for class CFSDirectory. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef AGL_STUB +#include +#endif + +#include +#include +#include +#include +#include +#include + +#ifdef AGL_STUB +#include +#endif +#include + +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_types.h" +#include "ns_npp_fs_directory.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CFSDirectory +/// Constructor of CFSDirectory class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CFSDirectory::CFSDirectory() { // LCOV_EXCL_START 8: all methods are static + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CFSDirectory +/// Destructor of CFSDirectory class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CFSDirectory::~CFSDirectory() { // LCOV_EXCL_START 8: all methods are static + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CreateDirectory +/// Method to create a directory. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CFSDirectory::CreateDirectory(const std::string &f_cdirpath) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (!f_cdirpath.empty()) { + PSTR l_cTempDirPath; + PSTR l_cParsedDirPath; + PCSTR l_cCopypath = f_cdirpath.c_str(); + + l_cTempDirPath = const_cast(f_cdirpath.c_str()); + while (l_estatus == eFrameworkunifiedStatusOK && (l_cParsedDirPath = std::strchr(l_cTempDirPath, '/')) != 0) { + if (l_cParsedDirPath != l_cTempDirPath) { + /* Neither root nor double slash in path */ + *l_cParsedDirPath = '\0'; + if (0 != mkdir(l_cCopypath, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) { // LCOV_EXCL_BR_LINE 5: mkdir's error case // NOLINT[whitespace/line_length] + if (EEXIST != errno) { // LCOV_EXCL_BR_LINE 5: errno can't be changed + // LCOV_EXCL_START 5: errno can't be changed + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error Cannot Create directory %s", l_cCopypath); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } else { + // file already exist + } + } + *l_cParsedDirPath = '/'; + } + l_cTempDirPath = l_cParsedDirPath + 1; + } + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 200: l_estatus must be eFrameworkunifiedStatusOK + if (0 != mkdir(l_cCopypath, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) { // LCOV_EXCL_BR_LINE 5: mkdir's error case // NOLINT[whitespace/line_length] + if (EEXIST != errno) { // LCOV_EXCL_BR_LINE 5: errno can't be changed + // LCOV_EXCL_START 5: errno can't be changed + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error Cannot Create directory %s", l_cCopypath); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } else { + // file already exist + } + } + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Directory path is empty."); + l_estatus = eFrameworkunifiedStatusFail; + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// DoesDirecotryExist +/// Method to check if a directory exists. +//////////////////////////////////////////////////////////////////////////////////////////////////// +BOOL CFSDirectory::DoesDirecotryExist(const std::string &f_cdirpath) { + DIR *l_pDirDescriptor = opendir(f_cdirpath.c_str()); + if (NULL != l_pDirDescriptor) { + closedir(l_pDirDescriptor); + return TRUE; + } + return FALSE; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// IsDirectory +/// Method to check if the entity is a directory. +//////////////////////////////////////////////////////////////////////////////////////////////////// +BOOL CFSDirectory::IsDirectory(const std::string &f_cpath) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + BOOL l_bReturn = FALSE; + + if (!f_cpath.empty()) { // LCOV_EXCL_BR_LINE 200: f_cpath can't be empty + struct stat st_buf; + + if (0 == stat(f_cpath.c_str(), &st_buf)) { // LCOV_EXCL_BR_LINE 5: stat's error case + // Get the status of the file + if (S_ISREG(st_buf.st_mode)) { + l_bReturn = FALSE; // return false if f_cpath is a regular file + } + if (S_ISDIR(st_buf.st_mode)) { + l_bReturn = TRUE; // return true if f_cpath is a directory + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving status of path : %s", f_cpath.c_str()); // LCOV_EXCL_LINE 5: stat's error case // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Directory path is empty."); // LCOV_EXCL_LINE 200: f_cpath can't be empty + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_bReturn; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// RemoveDirectory +/// Method to remove a directory. +//////////////////////////////////////////////////////////////////////////////////////////////////// +BOOL CFSDirectory::RemoveDirectory(std::string f_cpath, const UI_32 f_uidelay) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + BOOL l_bReturn = FALSE; + + if (!f_cpath.empty()) { // LCOV_EXCL_BR_LINE 200: f_cpath can't be empty. + std::string l_cFilePath = ""; + + struct dirent *l_pdirent = NULL; + DIR *l_pdir = NULL; + + l_pdir = opendir(f_cpath.c_str()); // LCOV_EXCL_BR_LINE 11:unexpected branch + if (NULL != l_pdir) { + if ('/' != f_cpath[f_cpath.length() - 1]) { + f_cpath.append("/"); + } + + while (NULL != (l_pdirent = readdir(l_pdir))) { + if (0 != std::strcmp(l_pdirent->d_name, ".") && + 0 != std::strcmp(l_pdirent->d_name, "..")) { + l_cFilePath.assign(f_cpath); + l_cFilePath.append(l_pdirent->d_name); // concatenate the strings to get the complete f_cpath + + if (TRUE == IsDirectory(l_cFilePath)) { + (void)RemoveDirectory(l_cFilePath, f_uidelay); + } else { + // it's a file, we can use unlink + unlink(l_cFilePath.c_str()); + + if (0 < f_uidelay) { // LCOV_EXCL_START 200: f_uidelay is 0 + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert +#ifdef AGL_PosixBasedOS001LEGACY_USED + delay(f_uidelay); +#endif + } + // LCOV_EXCL_STOP + } + } + } + closedir(l_pdir); // close the directory + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pdir is NULL"); + } + + // delete the directory + if (0 == rmdir(f_cpath.c_str())) { + if (0 < f_uidelay) { // LCOV_EXCL_START 200: f_uidelay is 0 + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert +#ifdef AGL_PosixBasedOS001LEGACY_USED + delay(f_uidelay); +#endif + } + // LCOV_EXCL_STOP + l_bReturn = TRUE; + } + } else { + // LCOV_EXCL_START 200: f_cpath can't be empty. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Directory path is empty."); + l_bReturn = FALSE; + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_bReturn; +} diff --git a/service/native/notification_persistent_service/server/src/ns_npp_handlelist.cpp b/service/native/notification_persistent_service/server/src/ns_npp_handlelist.cpp new file mode 100755 index 0000000..c9e88a8 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_handlelist.cpp @@ -0,0 +1,149 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup tag_NS_NPPService +/// \ingroup tag_NS_NPPService +/// +////////////////////////////////////////////////////////////////////////////////////////////////// + +////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This class holds the message queue handles for notification subscribers +/// +/// This is a singleton class which holds the message queue handles for notification subscribers. +/// This will ensure that NS_NPPService will hold only one handle per subscriber. +////////////////////////////////////////////////////////////////////////////////////////////////// +#include +#include +#include "ns_npp_handlelist.h" +#include "ns_npp_notificationpersistentservicelog.h" + +// define static member of class CHandleList +CHandleList *CHandleList::m_psHandleList = NULL; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CHandleList +/// Class Constructor +//////////////////////////////////////////////////////////////////////////////////////////////////// +CHandleList::CHandleList() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CHandleList +/// Class Destructor +//////////////////////////////////////////////////////////////////////////////////////////////////// +CHandleList::~CHandleList() { // LCOV_EXCL_START 14: Resident process, global instance not released + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// GetHandleList +/// This function is used to get the singleton instance of class. +//////////////////////////////////////////////////////////////////////////////////////////////////// +CHandleList *CHandleList::GetHandleList() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // create the instance of class + if (NULL == m_psHandleList) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Creating handle list."); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" + m_psHandleList = new(std::nothrow) CHandleList(); // LCOV_EXCL_BR_LINE 11: unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return m_psHandleList; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ReleaseHandleList +/// This function is used to release the instance of class. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CHandleList::ReleaseHandleList() { // LCOV_EXCL_START 100: not used + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != m_psHandleList) { + delete m_psHandleList; + m_psHandleList = NULL; + } else { + l_estatus = eFrameworkunifiedStatusNullPointer; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// AddHandleInList +/// Add pair of subscriber name and corresponding handle in map. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CHandleList::AddHandleInList(std::string f_csubscribername, HANDLE f_hmqhandle) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + HandleListRetStatus_Type l_prRetValue; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + l_prRetValue = m_mHandleList.insert(make_pair(f_csubscribername, f_hmqhandle)); + if (false == l_prRetValue.second) { + l_estatus = eFrameworkunifiedStatusDuplicate; + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Handle exists in list for %s.", f_csubscribername.c_str()); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Handle added in list for %s.", f_csubscribername.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" + } + + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// RemoveHandleFromList +/// Remove handle for subscriber from the list. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CHandleList::RemoveHandleFromList(std::string f_csubscribername) { // LCOV_EXCL_START 100: not used + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + // TODO(my_username): Implementation of this function. + // NOTE: Right now this feature is not required. Let the NS_NPPService hold one handle for + // each subscriber, even if all the notifications are unsubscribed by subscriber. + return eFrameworkunifiedStatusOK; +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// GetSubscriberMqHandle +/// Get the message queue handle of a subscriber. +//////////////////////////////////////////////////////////////////////////////////////////////// +HANDLE CHandleList::GetSubscriberMqHandle(std::string f_csubscribername) { + HANDLE l_hMqHandle = NULL; + HandleList_Type::iterator l_itHandleList; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + l_itHandleList = m_mHandleList.find(f_csubscribername); + if (l_itHandleList != m_mHandleList.end()) { + l_hMqHandle = l_itHandleList->second; + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_hMqHandle; +} diff --git a/service/native/notification_persistent_service/server/src/ns_npp_nor_persistence_worker_thread.cpp b/service/native/notification_persistent_service/server/src/ns_npp_nor_persistence_worker_thread.cpp new file mode 100755 index 0000000..d4b1604 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_nor_persistence_worker_thread.cpp @@ -0,0 +1,747 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contain declaration of class CNorPersistenceWorker and CArchive. +/// Class CNorPersistenceWorker holds the implementation for worker thread. +/// Class CArchive holds the implementation for archive. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include +#include +#include + + +#include +#include +#include +#include +#include +#include + +#include +#include "ns_npp_types.h" +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_fs_directory.h" +#include "ns_npp_persistent_data.h" +#include "ns_npp_nor_persistence_worker_thread.h" + + + +typedef std::string NotificationName; +typedef std::map TTimerList; +static TTimerList g_mtimers; /// List of all the timers for immediate persistence notifications +CMutex g_objmutextimerdata; /// Mutex object on g_mtimers + +// Template function for NorWorkerCallback +template EFrameworkunifiedStatus NorWorkerCallback(HANDLE hthread) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + C *l_pClass = static_cast(FrameworkunifiedGetThreadSpecificData(hthread)); + + if (l_pClass) { // LCOV_EXCL_BR_LINE 6: l_pClass can't be NULL + l_estatus = (l_pClass->*M)(hthread); + } + return l_estatus; +} + +static FrameworkunifiedProtocolCallbackHandler aServiceHandlers[] = { // NOLINT (readability/naming) + { NOR_PERSISTENCE_TIMER_START, NorWorkerCallback}, + { NOR_PERSISTENCE_REGISTER, NorWorkerCallback}, + { NOR_PERSISTENCE_UNREGISTER, NorWorkerCallback}, + { NOR_PERSISTENCE_ONSHUTDOWN, NorWorkerCallback}, + { NOR_PERSISTENCE_CHANGE_CATEGORY, NorWorkerCallback} +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NSPNorPersistenceWorkerOnStart +/// Callback method on start of worker thread +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NSPNorPersistenceWorkerOnStart(HANDLE hthread) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (NULL != hthread) { // LCOV_EXCL_BR_LINE 6: hthread can't be NULL + // Note: this variable is made static just to ignore the resource leak showing in coverity analysis + static CNorPersistenceWorker *l_pcnorpersistenceworker = new(std::nothrow) CNorPersistenceWorker; + + if (NULL != l_pcnorpersistenceworker) { // LCOV_EXCL_BR_LINE 5: new's error case + l_estatus = FrameworkunifiedSetThreadSpecificData(hthread, l_pcnorpersistenceworker); + + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 4: NSFW error case + l_estatus = FrameworkunifiedAttachCallbacksToDispatcher( + hthread, AppName, aServiceHandlers, static_cast(_countof(aServiceHandlers))); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + delete l_pcnorpersistenceworker; + l_pcnorpersistenceworker = NULL; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 5: new's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Worker Object Null."); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: hthread can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Thread App Handle Null."); + l_estatus = eFrameworkunifiedStatusInvldHandle; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NSPNorPersistenceWorkerOnStop +/// Callback method on stop of worker thread +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NSPNorPersistenceWorkerOnStop(HANDLE hthread) { // LCOV_EXCL_START 200: can't test + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (NULL != hthread) { + CNorPersistenceWorker *l_pcnorpersistenceworker = static_cast(FrameworkunifiedGetThreadSpecificData( + hthread)); + + if (NULL != l_pcnorpersistenceworker) { + delete l_pcnorpersistenceworker; + l_pcnorpersistenceworker = NULL; + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Worker Object Null"); + l_estatus = eFrameworkunifiedStatusNullPointer; + } + + if (eFrameworkunifiedStatusOK != (l_estatus = FrameworkunifiedSetThreadSpecificData(hthread, NULL))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedSetThreadSpecificData error, status=%d", l_estatus); + } + + PCSTR l_cservice = FrameworkunifiedGetAppName(hthread); + if (NULL != l_cservice) { + if (eFrameworkunifiedStatusOK != (l_estatus = FrameworkunifiedDetachServiceFromDispatcher(hthread, l_cservice))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error detaching service %s from dispatcher, status=%d", l_cservice, l_estatus); + } + } else { + l_estatus = eFrameworkunifiedStatusNullPointer; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedGetAppName returned NULL"); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Thread App Handle Null."); + l_estatus = eFrameworkunifiedStatusInvldHandle; + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + + return l_estatus; +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// Class : CNorPersistenceWorker +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CNorPersistenceWorker +/// Constructor of CNorPersistenceWorker class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNorPersistenceWorker::CNorPersistenceWorker() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CNorPersistenceWorker +/// Destructor of CNorPersistenceWorker class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNorPersistenceWorker::~CNorPersistenceWorker() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// OnNorPersistenceTimerStart +/// This function starts the respective timer of the notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNorPersistenceWorker::OnNorPersistenceTimerStart(HANDLE f_hThread) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + TNorPersistenceNotifInfoHeader *l_ptNorPersistentData = NULL; + UI_32 l_ui32ReceivedDataLength = FrameworkunifiedGetMsgLength(f_hThread); + UI_8 *l_pui32ReceivedData = new(std::nothrow) UI_8[l_ui32ReceivedDataLength]; + + if (l_ui32ReceivedDataLength >= sizeof(TNorPersistenceNotifInfoHeader)) { // LCOV_EXCL_BR_LINE 200: l_ui32ReceivedDataLength is bigger than sizeof(TNorPersistenceNotifInfoHeader) // NOLINT[whitespace/line_length] + if (NULL != l_pui32ReceivedData) { // LCOV_EXCL_BR_LINE 5: new's error case + std::memset(l_pui32ReceivedData, 0, l_ui32ReceivedDataLength); + l_estatus = FrameworkunifiedGetMsgDataOfSize(f_hThread, l_pui32ReceivedData, l_ui32ReceivedDataLength, eSMRRelease); + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 4: NSFW error case + TTimerList::iterator l_itTimerList; + l_ptNorPersistentData = static_cast(static_cast(l_pui32ReceivedData)); + + g_objmutextimerdata.WriteLock(); + // find the corresponding timer object in the list of timers + l_itTimerList = g_mtimers.find(l_ptNorPersistentData->m_cnotificationname); + if (g_mtimers.end() != l_itTimerList) { // LCOV_EXCL_BR_LINE 200: the notification must be registered + if (NULL != (l_itTimerList->second)) { // LCOV_EXCL_BR_LINE 200: l_itTimerList->second can't be null + if (NULL != (l_itTimerList->second)->m_pui8HeaderAndData) { + delete[](l_itTimerList->second)->m_pui8HeaderAndData; + (l_itTimerList->second)->m_pui8HeaderAndData = NULL; + } + + // Update specific immediate persistence notification data + (l_itTimerList->second)->m_pui8HeaderAndData = l_pui32ReceivedData; + + // if corresponding timer is not already running start it. + if (!(l_itTimerList->second)->IsRunning()) { + (l_itTimerList->second)->Start(); + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Timer started, Notfn=%s", l_ptNorPersistentData->m_cnotificationname); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Timer already running for notfn %s. Data updated", + l_ptNorPersistentData->m_cnotificationname); + } + + l_estatus = eFrameworkunifiedStatusOK; + } else { + // LCOV_EXCL_START 200: l_itTimerList->second can't be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Immediate persistence: Timer object NULL for Notfn:%s.", + l_ptNorPersistentData->m_cnotificationname); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 200: the notification must be registered + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Immediate persistence notification not registered. Notification: %s ", + l_ptNorPersistentData->m_cnotificationname != 0 ? l_ptNorPersistentData->m_cnotificationname : NULL); + // LCOV_EXCL_STOP + } + g_objmutextimerdata.Unlock(); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "FrameworkunifiedGetMsgDataOfSize failed while retrieving immediate persistence notfn data. Status:0x%x ", l_estatus); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 5: new's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to allocate data. Can't persist."); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 200: l_ui32ReceivedDataLength is bigger than sizeof(TNorPersistenceNotifInfoHeader) + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusInvldBuf; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid data length received. Can't persist."); + // LCOV_EXCL_STOP + } + + if ((eFrameworkunifiedStatusOK != l_estatus) && (NULL != l_pui32ReceivedData)) { + delete[] l_pui32ReceivedData; + l_pui32ReceivedData = NULL; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// RegisterImmediatePersistNotification +/// It creates a timer corresponding to the notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNorPersistenceWorker::RegisterImmediatePersistNotification(HANDLE hthread) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + TImmediatePersistenceRegisterNotifInfo l_tRegisterNotifInfo = {}; + + if (sizeof(l_tRegisterNotifInfo) == FrameworkunifiedGetMsgLength(hthread)) { // LCOV_EXCL_BR_LINE 200: the size of msg must be sizeof(TImmediatePersistenceUnregisterNotifInfo) // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(hthread, &l_tRegisterNotifInfo, // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + sizeof(TImmediatePersistenceRegisterNotifInfo), eSMRRelease))) { + g_objmutextimerdata.WriteLock(); + + TTimerList::iterator l_itTimerList = g_mtimers.find(l_tRegisterNotifInfo.m_cnotificationname); + if (l_itTimerList != g_mtimers.end()) { // LCOV_EXCL_BR_LINE 6: notification can't be registered again + // LCOV_EXCL_START 6: notification can't be registered again + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Notification %s is already registered for immediate data persistence ", + l_tRegisterNotifInfo.m_cnotificationname); + // LCOV_EXCL_STOP + } else { + // create timer corresponding to notification + CTimerHelper *l_pTimerHelper = new CTimerHelper(); + if (NULL != l_pTimerHelper) { // LCOV_EXCL_BR_LINE 5: new's error case + l_pTimerHelper->SetTime(l_tRegisterNotifInfo.m_uidelay, 0); + // todo: modify SetNotifyMethod of timer NSTimer class to accept sender handle as well. + // This will help to have only one handle, instead of one handle per timer. + l_pTimerHelper->SetNotifyMethod(static_cast(l_pTimerHelper->GetCmdId()), FrameworkunifiedGetAppName(hthread)); + + // associate timer's timeout with the callback function. + FrameworkunifiedAttachCallbackToDispatcher(hthread, TIMER_QUE, l_pTimerHelper->GetCmdId(), + boost::bind(&CTimerHelper::OnTimeOut, l_pTimerHelper, hthread)); + // add created timer in timers list + g_mtimers.insert(std::make_pair(l_tRegisterNotifInfo.m_cnotificationname, l_pTimerHelper)); + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Notification %s is registered for immediate data persistence ", + l_tRegisterNotifInfo.m_cnotificationname != 0 ? l_tRegisterNotifInfo.m_cnotificationname : NULL); + } + } + + g_objmutextimerdata.Unlock(); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error getting message data for registering Immediate persistent notification, status: 0x%x", l_estatus); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 200: the size of msg must be sizeof(TImmediatePersistenceUnregisterNotifInfo) + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "FrameworkunifiedGetMsgLength and size of TImmediatePersistenceRegisterNotifInfo mismatched." + "Length received %d, buffer available: %ld ", + FrameworkunifiedGetMsgLength(hthread), static_cast(sizeof(TImmediatePersistenceRegisterNotifInfo))); // NOLINT (runtime/int) + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// UnregisterImmediatePersistNotification +/// It deletes a timer corresponding to the notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNorPersistenceWorker::UnregisterImmediatePersistNotification(HANDLE hthread) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + TImmediatePersistenceUnregisterNotifInfo l_tRegisterNotifInfo = {}; + + if (sizeof(l_tRegisterNotifInfo) == FrameworkunifiedGetMsgLength(hthread)) { // LCOV_EXCL_BR_LINE 200: the size of msg must be sizeof(TImmediatePersistenceUnregisterNotifInfo) // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(hthread, &l_tRegisterNotifInfo, // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + sizeof(TImmediatePersistenceUnregisterNotifInfo), eSMRRelease))) { + g_objmutextimerdata.WriteLock(); + + TTimerList::iterator l_itTimerList = g_mtimers.find(l_tRegisterNotifInfo.m_cnotificationname); + if (l_itTimerList != g_mtimers.end()) { // LCOV_EXCL_BR_LINE 6: notification can't be unregistered again + if (NULL != (l_itTimerList->second)) { // LCOV_EXCL_BR_LINE 200: l_itTimerList->second can't be null + EFrameworkunifiedStatus eStatus; + // detach callbacks + if (eFrameworkunifiedStatusOK != (eStatus = FrameworkunifiedDetachCallbackFromDispatcher(hthread, TIMER_QUE, // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + (l_itTimerList->second)->GetCmdId()))) { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: FrameworkunifiedDetachCallbackFromDispatcher Failed Status:0x%x ", eStatus); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + delete l_itTimerList->second; + l_itTimerList->second = NULL; + } + g_mtimers.erase(l_itTimerList); + } else { + // LCOV_EXCL_START 6: notification can't be registered again + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + "Can't unregister. Notification %s is not a registered notification for immediate data persistence.", + l_tRegisterNotifInfo.m_cnotificationname != 0 ? l_tRegisterNotifInfo.m_cnotificationname : NULL); + // LCOV_EXCL_STOP + } + + g_objmutextimerdata.Unlock(); + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + "Notification %s is unregistered for immediate data persistence, FrameworkunifiedGetMsgDataOfSize Error, status: 0x%x", + l_tRegisterNotifInfo.m_cnotificationname != 0 ? l_tRegisterNotifInfo.m_cnotificationname : NULL, + l_estatus); + } + } else { + // LCOV_EXCL_START 200: the size of msg must be sizeof(TImmediatePersistenceUnregisterNotifInfo) + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "FrameworkunifiedGetMsgLength and size of TImmediatePersistenceUnregisterNotifInfo mismatched." + "Length received %d, buffer available: %ld ", + FrameworkunifiedGetMsgLength(hthread), static_cast(sizeof(TImmediatePersistenceUnregisterNotifInfo))); // NOLINT (runtime/int) + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// OnShutdown +/// This API saves or deletes the data of NOR irrespective of delay depending on the message data +/// received from parent thread during shutdown. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNorPersistenceWorker::OnShutdown(HANDLE f_hThread) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + UI_32 l_uiPersistCategoryFlag = 0; + + TImmediateShutdown l_tImmShutdown = {}; + + CTimerHelper *l_pTimerHelper = NULL; + + // iterator of list of nor notifications and its timers + TTimerList::iterator l_itTimerList; + + TNorPersistenceNotifInfoHeader *l_ptImmediateNotfnHeader = NULL; + + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(f_hThread, &l_tImmShutdown, sizeof(l_tImmShutdown), // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + eSMRRelease))) { + l_uiPersistCategoryFlag = l_tImmShutdown.f_uinotificationpersistentservicepersistcategoryflag; + + // if quick shutdown is received then just stop the timer and dont save the data + if (eFrameworkunifiedQuickShutdown == l_tImmShutdown.f_eshutdowntype) { + for (l_itTimerList = g_mtimers.begin(); l_itTimerList != g_mtimers.end(); l_itTimerList++) { + l_pTimerHelper = l_itTimerList->second; + + if (NULL != l_pTimerHelper && l_pTimerHelper->IsRunning()) { + // stop the timer + l_pTimerHelper->Stop(); + } + } + } else { // stop the timer and save the data + for (l_itTimerList = g_mtimers.begin(); l_itTimerList != g_mtimers.end(); l_itTimerList++) { + l_pTimerHelper = l_itTimerList->second; + + if (NULL != l_pTimerHelper && l_pTimerHelper->IsRunning()) { + // stop the timer + l_pTimerHelper->Stop(); + + l_ptImmediateNotfnHeader = static_cast + (static_cast(l_pTimerHelper->m_pui8HeaderAndData)); + + if (NULL != l_ptImmediateNotfnHeader) { // LCOV_EXCL_BR_LINE 200: l_ptImmediateNotfnHeader can't be null + if (eFrameworkunifiedUserData != (l_ptImmediateNotfnHeader->m_epersistcategory & l_uiPersistCategoryFlag) && + eFrameworkunifiedFactoryData != (l_ptImmediateNotfnHeader->m_epersistcategory & l_uiPersistCategoryFlag) && + eFrameworkunifiedFactoryCustomerData != (l_ptImmediateNotfnHeader->m_epersistcategory & l_uiPersistCategoryFlag) && + eFrameworkunifiedDealerData != (l_ptImmediateNotfnHeader->m_epersistcategory & l_uiPersistCategoryFlag)) { + // save the new data to persistent memory + l_pTimerHelper->OnTimeOut(f_hThread); + } + } else { + // LCOV_EXCL_START 200: l_ptImmediateNotfnHeader can't be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Immediate notification data header is NULL"); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + } + } + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedGetMsgDataOfSize failed for protocol NOR_PERSISTENCE_ONSHUTDOWN, status : %d", + l_estatus); + // LCOV_EXCL_STOP + } + + if (eFrameworkunifiedStatusOK != (l_estatus = FrameworkunifiedSendParent(f_hThread, NOR_PERSISTENCE_ONSHUTDOWN_ACK, // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + sizeof(l_uiPersistCategoryFlag), &l_uiPersistCategoryFlag))) { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedSendParent failed for protocol NOR_PERSISTENCE_ONSHUTDOWN_ACK, status : %d", + l_estatus); + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// OnCategoryChange +/// This callback is called when category of immediate persistence is changed +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNorPersistenceWorker::OnCategoryChange(HANDLE hthread) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != hthread) { // LCOV_EXCL_BR_LINE 4: NSFW error case + UI_32 l_ui32ReceivedDataLength = FrameworkunifiedGetMsgLength(hthread); + + if (l_ui32ReceivedDataLength >= sizeof(TImmediatePersistenceChangeCategory)) { // LCOV_EXCL_BR_LINE 200: l_ui32ReceivedDataLength is bigger than sizeof(TImmediatePersistenceChangeCategory) // NOLINT[whitespace/line_length] + UI_8 *l_pui32ReceivedData = new(std::nothrow) UI_8[l_ui32ReceivedDataLength]; + + if (NULL != l_pui32ReceivedData) { // LCOV_EXCL_BR_LINE 5: new's error case + std::memset(l_pui32ReceivedData, 0, l_ui32ReceivedDataLength); + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(hthread, l_pui32ReceivedData, l_ui32ReceivedDataLength, // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + eSMRRelease))) { + TImmediatePersistenceChangeCategory *l_pChangePersistentCategory = + static_cast(static_cast(l_pui32ReceivedData)); + PUI_8 l_pui8Data = l_pui32ReceivedData + sizeof(TImmediatePersistenceChangeCategory); + + TTimerList::iterator l_itTimerList; + + g_objmutextimerdata.WriteLock(); + // find the corresponding timer object in the list of timers + l_itTimerList = g_mtimers.find(l_pChangePersistentCategory->m_tnornotifInfoheader.m_cnotificationname); + if (g_mtimers.end() != l_itTimerList) { // LCOV_EXCL_BR_LINE 6: notification must be in list + CTimerHelper *l_pTimerHelper = l_itTimerList->second; + + if (NULL != l_pTimerHelper && l_pTimerHelper->IsRunning()) { + TNorPersistenceNotifInfoHeader *l_ptImmediateNotfnHeader = + static_cast(static_cast(l_pTimerHelper->m_pui8HeaderAndData)); + + if (NULL != l_ptImmediateNotfnHeader) { // LCOV_EXCL_BR_LINE 200: l_ptImmediateNotfnHeader can't be null + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Changing category from %d to %d for notfn %s in dataHdr", + l_ptImmediateNotfnHeader->m_epersistcategory, + l_pChangePersistentCategory->m_tnornotifInfoheader.m_epersistcategory, + l_ptImmediateNotfnHeader->m_cnotificationname); + + l_ptImmediateNotfnHeader->m_epersistcategory = + l_pChangePersistentCategory->m_tnornotifInfoheader.m_epersistcategory; + } + } + + EFrameworkunifiedPersistCategory l_eOldPersistCategory = l_pChangePersistentCategory->m_eoldpersistcategory; + + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Changing persist category of %s from %d to %d", + l_pChangePersistentCategory->m_tnornotifInfoheader.m_cnotificationname, + l_eOldPersistCategory, + l_pChangePersistentCategory->m_tnornotifInfoheader.m_epersistcategory); + + // write data to emmc + l_estatus = SynchronousWritePersistentData( + l_pChangePersistentCategory->m_tnornotifInfoheader.m_cpublishername, + l_pChangePersistentCategory->m_tnornotifInfoheader.m_cnotificationname, + static_cast(l_pui8Data), + l_pChangePersistentCategory->m_tnornotifInfoheader.m_uimsgsize, + l_pChangePersistentCategory->m_tnornotifInfoheader.m_uidelay, + l_pChangePersistentCategory->m_tnornotifInfoheader.m_uimaxmsglength, + l_pChangePersistentCategory->m_tnornotifInfoheader.m_epersistcategory); + + // Create the old file path string to be removed + std::string l_cPath = IMMEDIATE_PERSISTENCE_STORAGE_V2; + std::string l_cTempPath = l_pChangePersistentCategory->m_tnornotifInfoheader.m_cnotificationname; + size_t l_uiTempPathSize = 0; + + // replace all '/' by '_' + l_uiTempPathSize = l_cTempPath.find_first_of("/"); + while (std::string::npos != l_uiTempPathSize) { + l_cTempPath[l_uiTempPathSize] = '_'; + l_uiTempPathSize = l_cTempPath.find_first_of("/", l_uiTempPathSize + 1); + } + + switch (l_eOldPersistCategory) { + case eFrameworkunifiedFactoryData: + l_cPath.append(FACTORYDATADIR); + break; + case eFrameworkunifiedFactoryCustomerData: + l_cPath.append(FACTORYCUSTOMERDATADIR); + break; + case eFrameworkunifiedDealerData: + l_cPath.append(DEALERDATADIR); + break; + case eFrameworkunifiedUserData: + default: { + l_cPath.append(USERDATADIR); + l_cPath.append(ALLUSERAPPDATADIR); + } + break; + } + + l_cPath.append(IMMEDIATEDATADIR); + l_cPath.append(l_cTempPath); + + l_cPath.append(l_pChangePersistentCategory->m_tnornotifInfoheader.m_cpublishername); + + if (0 != unlink(l_cPath.c_str())) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error deleting file %s, errno=%d", l_cPath.c_str(), errno); + } + } else { + // LCOV_EXCL_START 6: notification must be in list + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't update persistent category, notfn %s not found in g_mtimers map", + l_pChangePersistentCategory->m_tnornotifInfoheader.m_cnotificationname != 0 ? + l_pChangePersistentCategory->m_tnornotifInfoheader.m_cnotificationname : NULL); + // LCOV_EXCL_STOP + } + g_objmutextimerdata.Unlock(); + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedGetMsgDataOfSize failed while retrieving" + "immediate persistence notfn data. Status:0x%x ", l_estatus); + // LCOV_EXCL_STOP + } + + delete[] l_pui32ReceivedData; + l_pui32ReceivedData = NULL; + } else { + // LCOV_EXCL_START 5: new's error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to allocate data. Can't persist, errno=%d", errno); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 200: l_ui32ReceivedDataLength is bigger than sizeof(TImmediatePersistenceChangeCategory) + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusInvldBuf; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid data length received %d. Can't persist.", l_ui32ReceivedDataLength); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid param, hthread is NULL"); + l_estatus = eFrameworkunifiedStatusInvldParam; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +///////////////////////////// +/// Class: CTimerHelper +///////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CTimerHelper +/// Constructor of CTimerHelper class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CTimerHelper::CTimerHelper() { + static UI_32 l_uiTimerCounter = PROTOCOL_FRAMEWORKUNIFIED_BASE_CMD; + l_uiTimerCounter++; + m_uiCmdId = l_uiTimerCounter; + m_pui8HeaderAndData = NULL; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CTimerHelper +/// Destructor of CTimerHelper class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CTimerHelper::~CTimerHelper() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != m_pui8HeaderAndData) { + delete[] m_pui8HeaderAndData; + m_pui8HeaderAndData = NULL; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// GetCmdId +/// Returns id for timer +//////////////////////////////////////////////////////////////////////////////////////////////////// +UI_32 CTimerHelper::GetCmdId() { + return m_uiCmdId; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// OnTimeOut +/// This function writes the corresponding data in NOR when timer expires. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CTimerHelper::OnTimeOut(HANDLE hthread) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + g_objmutextimerdata.ReadLock(); + if (NULL != m_pui8HeaderAndData) { // LCOV_EXCL_BR_LINE 200: m_pui8HeaderAndData can't be null + TNorPersistenceNotifInfoHeader *l_ptImmediateNotfnHeader = + static_cast(static_cast(m_pui8HeaderAndData)); + PUI_8 l_pui8Data = m_pui8HeaderAndData + sizeof(TNorPersistenceNotifInfoHeader); + HANDLE l_hReceiverMq = McOpenSender(l_ptImmediateNotfnHeader->m_cpublishername); + + // write data to emmc + l_estatus = SynchronousWritePersistentData(l_ptImmediateNotfnHeader->m_cpublishername, + l_ptImmediateNotfnHeader->m_cnotificationname, + static_cast(l_pui8Data), + l_ptImmediateNotfnHeader->m_uimsgsize, + l_ptImmediateNotfnHeader->m_uidelay, + l_ptImmediateNotfnHeader->m_uimaxmsglength, + l_ptImmediateNotfnHeader->m_epersistcategory); + + // update corresponding application about data written status. + if (NULL != l_hReceiverMq) { // LCOV_EXCL_BR_LINE 5: NSFW error case + NC_ImmediateWriteAck l_tWriteAck = {}; + std::strncpy(l_tWriteAck.notificationName, l_ptImmediateNotfnHeader->m_cnotificationname, + sizeof(l_tWriteAck.notificationName) - 1); + l_tWriteAck.eStatus = l_estatus; + + if (eFrameworkunifiedStatusOK != (l_estatus = McSend(l_hReceiverMq, AppName, NPS_IMMEDIATE_WRITE_ACK, sizeof(l_tWriteAck), // LCOV_EXCL_BR_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + &l_tWriteAck))) { + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error Sending NPS_IMMEDIATE_WRITE_ACK to %s for %s, Status: %d", + l_ptImmediateNotfnHeader->m_cpublishername != 0 ? l_ptImmediateNotfnHeader->m_cpublishername : NULL, + l_ptImmediateNotfnHeader->m_cnotificationname != 0 ? + l_ptImmediateNotfnHeader->m_cnotificationname : NULL, + l_estatus); + // LCOV_EXCL_STOP + } + McClose(l_hReceiverMq); + l_hReceiverMq = NULL; + } else { + // LCOV_EXCL_START 5: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error creating sender handle for service %s, Notification name %s Write Status: %d", + l_ptImmediateNotfnHeader->m_cpublishername != 0 ? l_ptImmediateNotfnHeader->m_cpublishername : NULL, + l_ptImmediateNotfnHeader->m_cnotificationname != 0 ? + l_ptImmediateNotfnHeader->m_cnotificationname : NULL, + l_estatus); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 200: m_pui8HeaderAndData can't be null + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Not writing immediate persistence data. Data is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + // LCOV_EXCL_STOP + } + g_objmutextimerdata.Unlock(); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +/// EOF diff --git a/service/native/notification_persistent_service/server/src/ns_npp_notification.cpp b/service/native/notification_persistent_service/server/src/ns_npp_notification.cpp new file mode 100755 index 0000000..8e2bb2d --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_notification.cpp @@ -0,0 +1,485 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of CNotification class. +/// It define functionalities common to all types of notification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include +#include +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_handlelist.h" +#include "ns_npp_notification.h" + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CNotification +/// Constructor of CNotification class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNotification::CNotification() { // LCOV_EXCL_START 8: dead code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_cNotificationName = ""; + m_uiMaxMsgSize = 0; + m_ePersistentType = eFrameworkunifiedUnknown; + + m_cServiceName = ""; + + m_pmSubscribersList = NULL; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CNotification +/// Constructor of CNotification class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNotification::CNotification(const std::string &f_cnotificationname, + const UI_32 f_uimaxmsgsize) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_cNotificationName = ""; + m_uiMaxMsgSize = 0; + m_ePersistentType = eFrameworkunifiedUnknown; + m_pmSubscribersList = NULL; + + if (!f_cnotificationname.empty()) { // LCOV_EXCL_BR_LINE 200: f_cnotificationname can't be empty + m_cNotificationName = f_cnotificationname; + m_uiMaxMsgSize = f_uimaxmsgsize; +// m_ePersistentType = eFrameworkunifiedUnknown; + + m_cServiceName = ""; + + m_pmSubscribersList = new(std::nothrow) NotifReceiver_Type(); // LCOV_EXCL_BR_LINE 11:unexpected branch + } else { + // LCOV_EXCL_START 200: f_cnotificationname can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Notification String is Empty"); + + CNotification(); + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CNotification +/// Destructor of CNotification class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNotification::~CNotification() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // iterator of CNotificationReceiver map + NotifReceiver_Iterator_Type l_itNotifReceiver; + + CNotificationReceiver *l_pNotificationReceiver = NULL; + + if (NULL != m_pmSubscribersList) { // LCOV_EXCL_BR_LINE 6: m_pmSubscribersList can't be NULL + if (!m_pmSubscribersList->empty()) { + for (l_itNotifReceiver = m_pmSubscribersList->begin(); + l_itNotifReceiver != m_pmSubscribersList->end(); + l_itNotifReceiver++) { + l_pNotificationReceiver = (*l_itNotifReceiver).second; + + if (NULL != l_pNotificationReceiver) { // LCOV_EXCL_BR_LINE 6: l_pNotificationReceiver can't be NULL + // NOTE: Uncomment following code when implementation of the function RemoveHandleFromList + // is available. To find the reason why it is not implemented, see the function definition. + // CHandleList *l_hHandleList = CHandleList::GetHandleList(); + // l_hHandleList->RemoveHandleFromList((*l_itNotifReceiver).first); + + delete l_pNotificationReceiver; // LCOV_EXCL_BR_LINE 11: unexpected branch + l_pNotificationReceiver = NULL; + } + } + + // clear the map + m_pmSubscribersList->clear(); + } + + delete m_pmSubscribersList; // LCOV_EXCL_BR_LINE 11: unexpected branch + m_pmSubscribersList = NULL; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// AddEventReciever +/// This function adds the name of the application to receiver list of particular notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotification::AddEventReciever(const std::string &f_csubscribername) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (!f_csubscribername.empty()) { // LCOV_EXCL_BR_LINE 6: f_csubscribername can't be empty + l_estatus = AddReceiverInMap(f_csubscribername); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusInvldParam; // LCOV_EXCL_LINE 6: f_csubscribername can't be empty + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// Publish +/// This function publishes the notification to subscribed clients. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotification::Publish(const std::string &f_cservicename, + PVOID f_pmessage, + const UI_32 f_uimsgsize) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eFrameworkunifiedStatusFail; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// DeleteEventReciever +/// This function deletes the name of application from receivers list. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotification::DeleteEventReciever(const std::string &f_csubscribername) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // iterator of CNotificationReceiver map + NotifReceiver_Iterator_Type l_iterator; + + CNotificationReceiver *l_pNotificationReceiver = NULL; + + if (!f_csubscribername.empty()) { // LCOV_EXCL_BR_LINE 6: double check, f_csubscribername can't be empty + l_iterator = m_pmSubscribersList->find(f_csubscribername); + + + if (l_iterator != m_pmSubscribersList->end()) { + l_pNotificationReceiver = (*l_iterator).second; + + if (NULL != l_pNotificationReceiver) { // LCOV_EXCL_BR_LINE 6: l_pNotificationReceiver can't be NULL + // NOTE: Uncomment following code when implementation of the function RemoveHandleFromList + // is available. To find the reason why it is not implemented, see the function definition. + // CHandleList *l_hHandleList = CHandleList::GetHandleList(); + // l_hHandleList->RemoveHandleFromList((*l_iterator).first); + + delete l_pNotificationReceiver; // LCOV_EXCL_BR_LINE 11: unexpected branch + l_pNotificationReceiver = NULL; + } + + m_pmSubscribersList->erase(l_iterator); + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Subscriber successfully deleted"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Invalid Iterator"); + } + } else { + // LCOV_EXCL_START 6: double check, f_csubscribername can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Subscriber Name String is Empty"); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SetNewSubscribersList +/// This function sets the subscribers list of notification +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotification::SetNewSubscribersList(CNotification *f_pnotification) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // iterator of CNotificationReceiver map + NotifReceiver_Iterator_Type l_itNotifReceiver; + + std::string l_cSubscriberName; + + if (NULL != f_pnotification && NULL != f_pnotification->m_pmSubscribersList) { // LCOV_EXCL_BR_LINE 6: f_pnotification and f_pnotification->m_pmSubscribersList can't be empty // NOLINT[whitespace/line_length] + if (!f_pnotification->m_pmSubscribersList->empty()) { + for (l_itNotifReceiver = f_pnotification->m_pmSubscribersList->begin(); + l_itNotifReceiver != f_pnotification->m_pmSubscribersList->end(); + l_itNotifReceiver++) { + l_cSubscriberName = (*l_itNotifReceiver).first; + AddReceiverInMap(l_cSubscriberName); // LCOV_EXCL_BR_LINE 11: unexpected branch + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Subscriber List Empty"); + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; // LCOV_EXCL_LINE 6: f_pnotification and f_pnotification->m_pmSubscribersList can't be empty // NOLINT[whitespace/line_length] + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SetEventPublisher +/// This function set the publisher name to current received service name +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotification::SetEventPublisher(const std::string &f_cservicename) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (!f_cservicename.empty()) { + m_cServiceName = f_cservicename; + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Service successfully set"); // LCOV_EXCL_BR_LINE 15: marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Service Name String is Empty"); + l_estatus = eFrameworkunifiedStatusFail; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ResetEventPublisher +/// This function resets the publisher name +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotification::ResetEventPublisher(const std::string &f_cservicename) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (f_cservicename.empty()) { // LCOV_EXCL_BR_LINE 6: f_cservicename can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusInvldParam; // LCOV_EXCL_LINE 6: f_cservicename can't be empty + } else { + if (0 == m_cServiceName.compare(f_cservicename)) { + m_cServiceName = ""; + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Service successfully reset"); // LCOV_EXCL_BR_LINE 15: marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Service Name Not Registered"); // LCOV_EXCL_BR_LINE 15: marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + l_estatus = eFrameworkunifiedStatusFail; + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +EFrameworkunifiedStatus CNotification::AddReceiverInMap(const std::string &f_csubscribername) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // Message Queue Handle for passsing messages + HANDLE l_hMsgSenQueHandle = NULL; + + // Pointer to class CNotificationReceiver + CNotificationReceiver *l_pCNotificationReceiver = NULL; + + // Iterator for Notification Receiver map + NotifReceiver_Iterator_Type l_itrNotifReceiver; + + if (!f_csubscribername.empty()) { // LCOV_EXCL_BR_LINE 6: f_csubscribername can't be empty + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Message Queue Handle Set"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + + CHandleList *l_hHandleList = CHandleList::GetHandleList(); + + l_hMsgSenQueHandle = l_hHandleList->GetSubscriberMqHandle(f_csubscribername); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + + // If handle not found + if (NULL == l_hMsgSenQueHandle) { + // Open a handle for sending messages to another message queue + l_hMsgSenQueHandle = McOpenSender(f_csubscribername.c_str()); + l_hHandleList->AddHandleInList(f_csubscribername, l_hMsgSenQueHandle); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + } + + if (NULL != m_pmSubscribersList) { // LCOV_EXCL_BR_LINE 6: m_pmSubscribersList can't be NULL + l_pCNotificationReceiver = new(std::nothrow) CNotificationReceiver(); // LCOV_EXCL_BR_LINE 11: unexpected branch + + if (NULL != l_pCNotificationReceiver) { // LCOV_EXCL_BR_LINE 5: l_pCNotificationReceiver can't be NULL + l_pCNotificationReceiver->m_MsgQHandle = l_hMsgSenQueHandle; + + // Insert Subscriber name and associated message queue handle in the map + m_pmSubscribersList->insert(make_pair(f_csubscribername, l_pCNotificationReceiver)); + } else { + // LCOV_EXCL_START 5: l_pCNotificationReceiver can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pCNotificationReceiver is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: m_pmSubscribersList can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "m_pmSubscribersList is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + + if (eFrameworkunifiedStatusNullPointer == l_estatus) { + // close the queue handle + // NOTE: Uncomment following code when implementation of the function RemoveHandleFromList + // is available. To find the reason why it is not implemented, see the function definition. + // CHandleList *l_hHandleList = CHandleList::GetHandleList(); + // l_hHandleList->RemoveHandleFromList(f_csubscribername); + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusInvldParam; // LCOV_EXCL_LINE 6: f_csubscribername can't be empty + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// PublishData +/// This function publishes the notification to client. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotification::PublishData(HANDLE f_hmsgqhandle, + const PVOID f_pmessage, + const UI_32 f_uimsgsize) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != f_hmsgqhandle) { // LCOV_EXCL_BR_LINE 6: f_hmsgqhandle can't be NULL + // Notification Name + PSTR l_cNotificationName = const_cast(m_cNotificationName.c_str()); + + if (eFrameworkunifiedStatusOK != (l_estatus = McSendWithSysInfo(f_hmsgqhandle, AppName, NPS_NOTIFY_EV_REQ, l_cNotificationName, f_uimsgsize, f_pmessage, 0))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "PublishData failed while McSend for Notification %s, Error Status: 0x%x", + l_cNotificationName, l_estatus); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: f_hmsgqhandle can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "MsgQ Handle NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// IsServiceRegistered +/// This function checks whether the notification is registered with any service or not. +//////////////////////////////////////////////////////////////////////////////////////////////////// +BOOL CNotification::IsServiceRegistered() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (!m_cServiceName.empty()) { + return TRUE; + } else { + return FALSE; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// IsSubscribersListEmpty +/// This function is used to check whether any service is subscribed to notification +//////////////////////////////////////////////////////////////////////////////////////////////////// +BOOL CNotification::IsSubscribersListEmpty() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != m_pmSubscribersList) { // LCOV_EXCL_BR_LINE 6: m_pmSubscribersList can't be NULL + if (m_pmSubscribersList->empty()) { + return TRUE; + } + } + + return FALSE; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// GetNotificationName +/// This function is used to get the notification name. +//////////////////////////////////////////////////////////////////////////////////////////////////// +std::string CNotification::GetNotificationName() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + return m_cNotificationName; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// GetPublisherName +/// This function is used to get the publisher name of notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +std::string CNotification::GetPublisherName() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + return m_cServiceName; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// GetPersistenceType +/// This function is used to get the type of notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedNotificationType CNotification::GetNotificationType() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + return m_ePersistentType; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// GetMaxMessageSize +/// This function is used to get the max size of data of notification message. +//////////////////////////////////////////////////////////////////////////////////////////////////// +UI_32 CNotification::GetMaxMessageSize() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + return m_uiMaxMsgSize; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// ResetMaxMessageSize +/// This function reset the max size of data that can be published with notification. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotification::ResetMaxMessageSize(const UI_32 f_uilength) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_uiMaxMsgSize = f_uilength; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +#ifdef NPP_PROFILEINFO_ENABLE + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// GetSubscriberList +/// Returns the list of subscribers subscribed to notification +//////////////////////////////////////////////////////////////////////////////////////////////// +NotifReceiver_Type *CNotification::GetSubscriberList() { + return m_pmSubscribersList; +} + +#endif diff --git a/service/native/notification_persistent_service/server/src/ns_npp_notification_manager.cpp b/service/native/notification_persistent_service/server/src/ns_npp_notification_manager.cpp new file mode 100755 index 0000000..73ce838 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_notification_manager.cpp @@ -0,0 +1,1558 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of singleton class CNotificationManager. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include +#include +#include "ns_npp_types.h" +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_threads.h" +#include "ns_npp_notification.h" +#include "ns_npp_persistent_data.h" +#include "ns_npp_state_notification.h" +#include "ns_npp_regular_notification.h" +#include "ns_npp_notification_manager.h" +#include "ns_npp_state_persistence_notification.h" +#include "ns_npp_state_nor_persistence_notification.h" +#include "ns_npp_state_persistence_user_notification.h" + +#ifdef NPP_PROFILEINFO_ENABLE +#include +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CNotificationManager +/// Constructor of CNotificationManager class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNotificationManager::CNotificationManager() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_pmNotificationList = new(std::nothrow) Notification_Type(); // LCOV_EXCL_BR_LINE 11: unexpected branch + + m_pvPersistentList = new(std::nothrow) std::vector(); // LCOV_EXCL_BR_LINE 11: unexpected branch + + m_pvUserPersistentList = new(std::nothrow) std::vector(); // LCOV_EXCL_BR_LINE 11: unexpected branch + + if (NULL == CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread) { // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread = + McOpenSender(NS_NPP_IMMEDIATE_PERSIST_THREAD_NAME); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CNotificationManager +/// Destructor of CNotificationManager class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNotificationManager::~CNotificationManager() { // LCOV_EXCL_START 14: Resident process, global instance not released + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // iterator to find notification from map of notifications + Notification_Iterator_Type l_itNotification; + + CNotification *l_pNotification = NULL; + + // delete the members in map of Notification + if (NULL != m_pmNotificationList) { + if (!m_pmNotificationList->empty()) { + for (l_itNotification = m_pmNotificationList->begin(); + l_itNotification != m_pmNotificationList->end(); + l_itNotification++) { + l_pNotification = (*l_itNotification).second; + + if (NULL != l_pNotification) { + delete l_pNotification; + l_pNotification = NULL; + } + } + + // clear the map + m_pmNotificationList->clear(); + } + + delete m_pmNotificationList; + m_pmNotificationList = NULL; + } + + // delete the members in vector of persistent notification + if (NULL != m_pvPersistentList) { + if (!m_pvPersistentList->empty()) { + // clear the vector + m_pvPersistentList->clear(); + } + + delete m_pvPersistentList; + m_pvPersistentList = NULL; + } + + // delete the members in vector of user persistent notification + if (NULL != m_pvUserPersistentList) { + if (!m_pvUserPersistentList->empty()) { + // clear the vector + m_pvUserPersistentList->clear(); + } + + delete m_pvUserPersistentList; + m_pvUserPersistentList = NULL; + } + + if (NULL != CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread) { + McClose(CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread); + CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread = NULL; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CreateNotificationObject +/// This function is used to get notification object from map. If doesn't exists, it create new +/// object as per type of notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNotification *CNotificationManager::CreateNotificationObject(const std::string &f_cnotificationname, + const UI_32 f_uimsglength, + const EFrameworkunifiedNotificationType f_enotificationtype, + const UI_32 f_uidelay) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // pointer of notification object + CNotification *l_pNotification = NULL; + + // iterator to find notification from map of CNotification + Notification_Iterator_Type l_itNotification; + + if (NULL == m_pmNotificationList || NULL == m_pvPersistentList || NULL == m_pvUserPersistentList) { // LCOV_EXCL_START 6: double check, m_pmNotificationList, m_pvPersistentList, m_pvUserPersistentList can't be NULL // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "map/vector object is NULL"); // LCOV_EXCL_LINE 6: m_pmNotificationList, m_pvPersistentList, m_pvUserPersistentList can't be NULL // NOLINT[whitespace/line_length] + return NULL; + } + // LCOV_EXCL_STOP + + // check if notification already exists + l_itNotification = m_pmNotificationList->find(f_cnotificationname); + + // if exists remove previous entry + if (m_pmNotificationList->end() != l_itNotification) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Removing previous entry of notification %s from map", f_cnotificationname.c_str()); + m_pmNotificationList->erase(l_itNotification); + } + + switch (f_enotificationtype) { + // if notification is regular notification + case eFrameworkunifiedNotificationVar: { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Regular Notification :: %s", f_cnotificationname.c_str()); + l_pNotification = new(std::nothrow) CRegularNotification(f_cnotificationname, + f_uimsglength); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + break; + } + + // if notification is state notification + case eFrameworkunifiedStateVar: { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "State Notification :: %s", f_cnotificationname.c_str()); + l_pNotification = new(std::nothrow) CStateNotification(f_cnotificationname, + f_uimsglength); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + break; + } + + // if notification is persistence notification + case eFrameworkunifiedPersistedStateVar: { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "PersistedState Notification :: %s", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + l_pNotification = new(std::nothrow) CStatePersistenceNotification(f_cnotificationname, + f_uimsglength); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + + if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 5: It's impossible to mock new() function + // insert notification in persistent notification vector + m_pvPersistentList->push_back(f_cnotificationname); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Memory not allocated"); // LCOV_EXCL_LINE 5: It's impossible to mock new() function // NOLINT[whitespace/line_length] + } + + break; + } + + // if notification is user persistence notification + case eFrameworkunifiedPersistedStateUserVar: { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "PersistedStateUser Notification :: %s", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + l_pNotification = new(std::nothrow) CStatePersistenceUserNotification(f_cnotificationname, + f_uimsglength); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + + if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 5: It's impossible to mock new() function + // insert notification in user persistent notification vector + m_pvUserPersistentList->push_back(f_cnotificationname); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "NULL pointer error"); // LCOV_EXCL_LINE 5: It's impossible to mock new() function // NOLINT[whitespace/line_length] + } + + break; + } + + // if notification is immediate persistence notification + case eFrameworkunifiedImmediatePersistedStateVar: { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Immediate PersistedState Notification :: %s", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + l_pNotification = new(std::nothrow) CStateNorPersistenceNotification(f_cnotificationname, + f_uimsglength, + f_uidelay); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + break; + } + + default: + break; + } + + if (NULL != l_pNotification) { + // insert notification in notification map + m_pmNotificationList->insert(make_pair(f_cnotificationname, l_pNotification)); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification object creation failed for %s.", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_pNotification; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SearchNotification +/// This function is used to search whether notification object is present in map or not. +/// If present it sends the reference. +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNotification *CNotificationManager::SearchNotification(const std::string &f_cnotificationname) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CNotification *l_pNotification = NULL; + + // iterator to find notification from map of notifications + Notification_Iterator_Type l_itNotification; + + if (NULL == m_pmNotificationList || f_cnotificationname.empty()) { // LCOV_EXCL_BR_LINE 6: double check, m_pmNotificationList can't be NULL and f_cnotificationname can't be empty // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "map pointer is NULL"); // LCOV_EXCL_LINE 6: m_pmNotificationList can't be NULL and f_cnotificationname can't be empty // NOLINT[whitespace/line_length] + } else { + // check if this notification's object present in map + l_itNotification = m_pmNotificationList->find(f_cnotificationname); + + // if notification found in map + if (m_pmNotificationList->end() != l_itNotification) { + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Notification found in map :: %s", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + + // get the notification object pointer from map + l_pNotification = (*l_itNotification).second; + } else { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Notification not found :: %s", f_cnotificationname.c_str()); + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_pNotification; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SearchPersistenceNotification +/// This function is used to search for the given persistent notification in map. +//////////////////////////////////////////////////////////////////////////////////////////////////// +CStateNotification *CNotificationManager::SearchPersistenceNotification(const std::string &f_cnotificationname) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // pointer of notification object + CNotification *l_pNotification = NULL; + CStateNotification *l_pStateNotification = NULL; + + // search the notification in the map + l_pNotification = SearchNotification(f_cnotificationname); + + if (NULL != l_pNotification) { + if (eFrameworkunifiedPersistedStateVar == l_pNotification->GetNotificationType() || + eFrameworkunifiedPersistedStateUserVar == l_pNotification->GetNotificationType() || + eFrameworkunifiedImmediatePersistedStateVar == l_pNotification->GetNotificationType()) { + l_pStateNotification = static_cast(l_pNotification); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "There is no persistence notification registered with name :: %s", + f_cnotificationname.c_str()); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_pStateNotification; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceServiceOnRegisterEvents +/// This function creates notification object depending on its type and if already created it adds +/// the service name to the list in the notification object. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceServiceOnRegisterEvents(const std::string &f_cservicename, + const std::string &f_cnotificationname, + const UI_32 f_uimsglength, + const EFrameworkunifiedNotificationType f_enotificationtype, + const UI_32 f_uidelay) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CNotification *l_pNotification = NULL; + + if (f_cservicename.empty() || f_cnotificationname.empty()) { + l_estatus = eFrameworkunifiedStatusInvldParam; + } else { + // get the notification object from map or create new object + l_pNotification = SearchNotification(f_cnotificationname); + + // if new notification is registered + if (NULL == l_pNotification) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Create new notification object :: %s", f_cnotificationname.c_str()); + + // create the new notification object depending on type and insert in map and vector + l_pNotification = CreateNotificationObject(f_cnotificationname, + f_uimsglength, + f_enotificationtype, + f_uidelay); + + if (NULL != l_pNotification) { + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Set Notification publisher %s for notification %s", f_cservicename.c_str(), + f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" + + // set publisher name + l_estatus = l_pNotification->SetEventPublisher(f_cservicename); + } + } else { // if notification object already exists + EFrameworkunifiedNotificationType l_eNotificationType = l_pNotification->GetNotificationType(); + + // <> + if (eFrameworkunifiedUnknown == l_eNotificationType) { + // creates new notification object depending on the type and insert it in notification map + l_estatus = ChangeNotificationType(l_pNotification, f_cservicename, f_cnotificationname, f_uimsglength, + f_enotificationtype, f_uidelay); + + // delete the old notification object + delete l_pNotification; // LCOV_EXCL_BR_LINE 11: unexpected branch + l_pNotification = NULL; + } else { // notification is already registered by some service + // update the notification property, if re-registered by the same publisher + if (f_cservicename == l_pNotification->GetPublisherName() || // if re-register by service + "" == l_pNotification->GetPublisherName()) { // if previously unregistered by service + // if type is same just update the length of notification data + if (l_eNotificationType == f_enotificationtype) { + if (l_pNotification->GetMaxMessageSize() != f_uimsglength) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + "Updating max size of notification %s to %d from %d", f_cnotificationname.c_str(), + f_uimsglength, l_pNotification->GetMaxMessageSize()); + l_estatus = l_pNotification->ResetMaxMessageSize(f_uimsglength); + } + + if ("" == l_pNotification->GetPublisherName()) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + "Updating publisher name of notification %s to %s from %s", f_cservicename.c_str(), + f_cnotificationname.c_str(), l_pNotification->GetPublisherName().c_str()); + l_pNotification->SetEventPublisher(f_cservicename); + } + } else if (eFrameworkunifiedImmediatePersistedStateVar != l_eNotificationType && + eFrameworkunifiedImmediatePersistedStateVar != f_enotificationtype) { + // else create new notification object depending on the type and delete the old one + // note: do not change immediate notification type + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Changing type of notfn %s from %d to %d", f_cnotificationname.c_str(), + l_eNotificationType, f_enotificationtype); + + std::vector::iterator l_itNotificationName; + + // remove the notification name from the persistent list of notification(if any) + if (eFrameworkunifiedPersistedStateVar == l_eNotificationType) { + l_itNotificationName = find(m_pvPersistentList->begin(), m_pvPersistentList->end(), f_cnotificationname); + + if (m_pvPersistentList->end() != l_itNotificationName) { + m_pvPersistentList->erase(l_itNotificationName); + } + } else if (eFrameworkunifiedPersistedStateUserVar == l_eNotificationType) { + l_itNotificationName = find(m_pvUserPersistentList->begin(), + m_pvUserPersistentList->end(), + f_cnotificationname); + + if (m_pvUserPersistentList->end() != l_itNotificationName) { + m_pvUserPersistentList->erase(l_itNotificationName); + } + } else { + // do nothing + } + + // creates new notification object depending on the new type and insert it in map and delete the old one + l_estatus = ChangeNotificationType(l_pNotification, f_cservicename, f_cnotificationname, f_uimsglength, + f_enotificationtype, f_uidelay); + + // delete the old notification object + delete l_pNotification; + l_pNotification = NULL; + } else { + // do nothing + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notfn: %s already registered by %s, skipping register request by %s", + f_cnotificationname.c_str(), l_pNotification->GetPublisherName().c_str(), f_cservicename.c_str()); + + l_estatus = eFrameworkunifiedStatusFail; + } + } + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// ChangeNotificationType +/// This function creates new notification object depending on the type and replaces the old one. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::ChangeNotificationType(CNotification *f_pnotification, + const std::string &f_cservicename, + const std::string &f_cnotificationname, + const UI_32 f_uimsglength, + const EFrameworkunifiedNotificationType f_enotificationtype, + const UI_32 f_uidelay) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CNotification *l_pNewNotification = NULL; + + if (NULL != f_pnotification) { // LCOV_EXCL_BR_LINE 6: f_pnotification can't be NULL + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Create New Notification :: %s", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + + // create new notification object as per notification type + l_pNewNotification = CreateNotificationObject(f_cnotificationname, f_uimsglength, f_enotificationtype, f_uidelay); + + if (NULL != l_pNewNotification) { + l_estatus = l_pNewNotification->SetEventPublisher(f_cservicename); + + // assign subscribers list to newly created notification + l_pNewNotification->SetNewSubscribersList(f_pnotification); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error creating notification object for notification:%s", + f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" + l_estatus = eFrameworkunifiedStatusNullPointer; + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; // LCOV_EXCL_LINE 6: f_pnotification can't be NULL + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceServiceOnUnRegisterEvents +/// This function removes the name of the service from the notification object. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceServiceOnUnRegisterEvents(const std::string &f_cservicename, + const std::string &f_cnotificationname) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CNotification *l_pNotification = NULL; + std::vector *l_pvPersistentList = NULL; + + // iterator to find notification from map of notifications + Notification_Iterator_Type l_itNotification; + + if (f_cservicename.empty() || f_cnotificationname.empty()) { + l_estatus = eFrameworkunifiedStatusInvldParam; + } else { + // check if this notification's object present in map + l_itNotification = m_pmNotificationList->find(f_cnotificationname); + + // if notification found in map + if (m_pmNotificationList->end() != l_itNotification) { + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Notification found in map"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + + // get the notification object pointer from map + l_pNotification = (*l_itNotification).second; + + if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 6: f_pnotification can't be NULL + if (eFrameworkunifiedPersistedStateUserVar == l_pNotification->GetNotificationType()) { + l_pvPersistentList = m_pvUserPersistentList; + } else if (eFrameworkunifiedPersistedStateVar == l_pNotification->GetNotificationType()) { + l_pvPersistentList = m_pvPersistentList; + } + + // reset the publisher name + l_estatus = l_pNotification->ResetEventPublisher(f_cservicename); + + if (eFrameworkunifiedStatusOK == l_estatus) { + // if no other service is subscribed to this notification and no service is registered + // to this notification remove the notification object from map + if (!l_pNotification->IsServiceRegistered() && + l_pNotification->IsSubscribersListEmpty()) { + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Deleting Notification Object"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + + // delete the notification + delete l_pNotification; // LCOV_EXCL_BR_LINE 11: unexpected branch + l_pNotification = NULL; + + m_pmNotificationList->erase(l_itNotification); + + if (l_pvPersistentList) { + // find the notification in vector + std::vector::iterator l_itNotificationName; + + l_itNotificationName = find(l_pvPersistentList->begin(), + l_pvPersistentList->end(), + f_cnotificationname); + + if (l_pvPersistentList->end() != l_itNotificationName) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Deleting Notification name from vector"); + l_pvPersistentList->erase(l_itNotificationName); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Persistent list empty"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Services still registered or subscriber list empty"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s is not registered by service %s", + f_cnotificationname.c_str(), f_cservicename.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + } else { + // LCOV_EXCL_START 6: f_pnotification can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s not registered", f_cnotificationname.c_str()); + + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s not found.", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + + l_estatus = eFrameworkunifiedStatusFail; + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceServiceOnPublishEvent +/// This function stores the published data in the notification object in case of state and +/// persistent notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceServiceOnPublishEvent(const std::string &f_cservicename, + const std::string &f_cnotificationname, + PVOID f_pmessage, + const UI_32 f_uimsgsize) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CNotification *l_pNotification = NULL; + + if (f_cservicename.empty() || f_cnotificationname.empty()) { // LCOV_EXCL_BR_LINE 6: f_cservicename and f_cnotificationname can't be empty // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusInvldParam; // LCOV_EXCL_LINE 6: f_cservicename and f_cnotificationname can't be empty + } else { + // get the notification object from map + l_pNotification = SearchNotification(f_cnotificationname); + + if (NULL != l_pNotification) { + // publish the notification + if (eFrameworkunifiedStatusOK != (l_estatus = l_pNotification->Publish(f_cservicename, + f_pmessage, + f_uimsgsize))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error publishing notification %s published by %s, status: %d", + f_cnotificationname.c_str(), f_cservicename.c_str(), l_estatus); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification not registered"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + + l_estatus = eFrameworkunifiedStatusNullPointer; + } + } + + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceServiceOnSubscribeToEvent +/// This function adds the name of the application to subscribers list in notification object. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceServiceOnSubscribeToEvent(const std::string &f_csubscribername, + const std::string &f_cnotificationname) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // iterator to find notification from map of notifications + Notification_Iterator_Type l_itNotification; + + CNotification *l_pNotification = NULL; + + if (f_cnotificationname.empty() || f_csubscribername.empty()) { + l_estatus = eFrameworkunifiedStatusInvldParam; + } else if (NULL == m_pmNotificationList) { // LCOV_EXCL_BR_LINE 6 m_pmNotificationList can't be NULL + // LCOV_EXCL_START 6: m_pmNotificationList can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "map pointer is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } else { + // get the notification object from map or create new object + l_pNotification = SearchNotification(f_cnotificationname); + + if (NULL == l_pNotification) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "CNotification object created for %s", f_cnotificationname.c_str()); + + l_pNotification = new(std::nothrow) CNotification(f_cnotificationname, 0); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + + m_pmNotificationList->insert(make_pair(f_cnotificationname, l_pNotification)); + } + + if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 6: double check, l_pNotification can't be NULL + // add subscribers name in subscribers list of notification + l_estatus = l_pNotification->AddEventReciever(f_csubscribername); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Memory not allocated for l_pNotification"); // LCOV_EXCL_LINE 6: double check, l_pNotification can't be NULL // NOLINT[whitespace/line_length] + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceServiceOnUnSubscribeFromEvent +/// This function removes the name of the application from the subscribers list in notification object. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceServiceOnUnSubscribeFromEvent(const std::string &f_csubscribername, + const std::string &f_cnotificationname) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CNotification *l_pNotification = NULL; + + // iterator to find notification from map of notifications + Notification_Iterator_Type l_itNotificationType; + + std::vector *l_pvPersistentList = NULL; + + if (f_cnotificationname.empty() || f_csubscribername.empty()) { + l_estatus = eFrameworkunifiedStatusInvldParam; + } else if (NULL == m_pmNotificationList) { // LCOV_EXCL_BR_LINE 6: m_pmNotificationList can't be NULL + // LCOV_EXCL_START 6: m_pmNotificationList can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification list pointer is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } else { + // check if this notification's object present in map + l_itNotificationType = m_pmNotificationList->find(f_cnotificationname); + + // if notification found in map + if (m_pmNotificationList->end() != l_itNotificationType) { + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Notification %s found in map", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + + l_pNotification = (*l_itNotificationType).second; + + if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 6: l_pNotification can't be NULL + if (eFrameworkunifiedPersistedStateUserVar == l_pNotification->GetNotificationType()) { + l_pvPersistentList = m_pvUserPersistentList; + } else if (eFrameworkunifiedPersistedStateVar == l_pNotification->GetNotificationType()) { + l_pvPersistentList = m_pvPersistentList; + } + + // removes the subscribers name from subscribers list of notification + l_estatus = l_pNotification->DeleteEventReciever(f_csubscribername); + + // if no other service is subscribed to this notification and no service is registered + // to this notification remove the notification object from map + if (!l_pNotification->IsServiceRegistered() && + l_pNotification->IsSubscribersListEmpty()) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Deleting Notification Object from map"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + + // delete notification object from map + delete l_pNotification; // LCOV_EXCL_BR_LINE 11: unexpected branch + l_pNotification = NULL; + + m_pmNotificationList->erase(l_itNotificationType); + + if (l_pvPersistentList) { + // find notification in vector + std::vector::iterator l_itNotificationName; + l_itNotificationName = find(l_pvPersistentList->begin(), + l_pvPersistentList->end(), + f_cnotificationname); + + if (l_pvPersistentList->end() != l_itNotificationName) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Deleting Notification from vector"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + l_pvPersistentList->erase(l_itNotificationName); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Persistent list Empty."); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + } + } else { + // LCOV_EXCL_START 6: l_pNotification can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Notification %s not registered", f_cnotificationname.c_str()); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + + } else { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Notification %s not found.", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + l_estatus = eFrameworkunifiedStatusFail; + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NPGetPersistentNotificationData +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::NPGetPersistentNotificationData(const std::string &f_cnotificationname, + PVOID f_pnotificationdata, + const UI_32 f_uidatasize) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CNotification *l_pNotification = NULL; + CStateNotification *l_pStateNotification = NULL; + const CPersistentData *l_pPersistentData = NULL; + + if (f_cnotificationname.empty() || NULL == f_pnotificationdata) { // LCOV_EXCL_BR_LINE 6: f_pnotificationdata can't be NULL and f_cnotificationname can't be empty // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusInvldParam; // LCOV_EXCL_LINE 6: f_pnotificationdata can't be NULL and f_cnotificationname can't be empty // NOLINT[whitespace/line_length] + } else { + l_pNotification = SearchNotification(f_cnotificationname); + + if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 200: f_cnotificationname must be NTFY_NPPService_UserChange, NTFY_NPPService_UserChange must be registered in FrameworkunifiedOnEntry() by itself. // NOLINT[whitespace/line_length] + const EFrameworkunifiedNotificationType l_eNotificationType = l_pNotification->GetNotificationType(); + + if (eFrameworkunifiedStateVar == l_eNotificationType || + eFrameworkunifiedPersistedStateVar == l_eNotificationType || + eFrameworkunifiedPersistedStateUserVar == l_eNotificationType || + eFrameworkunifiedImmediatePersistedStateVar == l_eNotificationType) { // LCOV_EXCL_BR_LINE 200: NTFY_NPPService_UserChange's type is eFrameworkunifiedPersistedStateVar. // NOLINT[whitespace/line_length] + l_pStateNotification = static_cast(l_pNotification); + + l_pPersistentData = l_pStateNotification->GetPersistentData(); + + if (NULL != l_pPersistentData) { + if (f_uidatasize >= l_pPersistentData->m_uiMsgSize) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Sending Data Size %d", l_pPersistentData->m_uiMsgSize); + + if (NULL != l_pPersistentData->m_pMessage) { + std::memcpy(f_pnotificationdata, l_pPersistentData->m_pMessage, l_pPersistentData->m_uiMsgSize); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Notification data is NULL"); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Smaller buffer size %d is received for notification data of size %d", f_uidatasize, + l_pPersistentData->m_uiMsgSize); + } + } else { + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Persistent data object is NULL for notification %s", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + } else { + // LCOV_EXCL_START 200: NTFY_NPPService_UserChange's type is eFrameworkunifiedPersistedStateVar. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Get notification data failed, Notification %s is registered as type %d", + f_cnotificationname.c_str(), l_eNotificationType); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 200: f_cnotificationname must be NTFY_NPPService_UserChange, NTFY_NPPService_UserChange must be registered in FrameworkunifiedOnEntry() by itself. // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s not found.", f_cnotificationname.c_str()); + // LCOV_EXCL_STOP + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceServiceOnGetPersistentData +/// This function is used to get the persistent data stored related to notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceServiceOnGetPersistentData(const std::string &f_cnotificationname, + const std::string &f_creceivername) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CNotification *l_pNotification = NULL; + CStateNotification *l_pStateNotification = NULL; + const CPersistentData *l_pPersistentData = NULL; + + if (f_cnotificationname.empty() || f_creceivername.empty()) { // LCOV_EXCL_BR_LINE 6: f_creceivername can't be NULL and f_cnotificationname can't be empty // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: f_creceivername can't be NULL and f_cnotificationname can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusInvldParam; + // LCOV_EXCL_STOP + } else { + // open the receiver message queue + HANDLE l_hReceiverMq = McOpenSender(f_creceivername.c_str()); + + if (NULL == l_hReceiverMq) { // LCOV_EXCL_BR_LINE 4: NSFW error case + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + // catastrophic failure! + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Failed to open MessageQ %s ", f_creceivername.c_str()); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } else { + // get the notification object from map or create new object + l_pNotification = SearchNotification(f_cnotificationname); + + if (NULL != l_pNotification) { + l_pStateNotification = static_cast(l_pNotification); + + if (NULL != l_pStateNotification) { // LCOV_EXCL_BR_LINE 5: fail safe for static_cast + l_pPersistentData = l_pStateNotification->GetPersistentData(); + + if (NULL != l_pPersistentData) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Sending Data Size %d", l_pPersistentData->m_uiMsgSize); + + if (NULL == l_pPersistentData->m_pMessage) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Sending Data is NULL"); + } + + // sent the notification data to requester + l_estatus = McSend(l_hReceiverMq, + AppName, + NPS_GET_PERS_DATA_ACK, + l_pPersistentData->m_uiMsgSize, + l_pPersistentData->m_pMessage); + FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Persistent data found for notification %s. " + "Sent NPS_GET_PERS_DATA_ACK to %s. Status: %d." + , f_cnotificationname.c_str(), f_creceivername.c_str(), l_estatus); + } else { // In case of failure, we send back a failure ACK + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "No persistent data found for notification %s. " + , f_cnotificationname.c_str()); + } + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s not found", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + l_estatus = eFrameworkunifiedStatusInvldParam; + } + // Close the mq handle + McClose(l_hReceiverMq); + l_hReceiverMq = NULL; + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceGetPersistentNotificationData +/// This function is used to get the list of persistent notifications and data associated with it. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceGetPersistentNotificationData(std::vector + *f_pvpersistnotification, + const EFrameworkunifiedNotificationType f_enotificationtype, + UI_32 f_uinotificationpersistentservicepersistcategoryflag) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CNotification *l_pNotification = NULL; + CStateNotification *l_pStateNotification = NULL; + CStatePersistenceNotification *l_pStatePersistenceNotification = NULL; + + std::string l_cNotificationName = ""; + CNotificationsToPersist *l_pNotificationsToPersist = NULL; + const CPersistentData *l_pPData = NULL; + + std::vector *l_pvPersistentList = NULL; + + // iterator for retrieving notifications from map of notifications + Notification_Iterator_Type l_itNotification; + + if (eFrameworkunifiedPersistedStateUserVar == f_enotificationtype) { + l_pvPersistentList = m_pvUserPersistentList; + } else if (eFrameworkunifiedPersistedStateVar == f_enotificationtype) { // LCOV_EXCL_BR_LINE 6: f_enotificationtype must be eFrameworkunifiedPersistedStateUserVar or eFrameworkunifiedPersistedStateVar // NOLINT[whitespace/line_length] + l_pvPersistentList = m_pvPersistentList; + } + + // copy all the notification data in map to received vector + if (NULL != f_pvpersistnotification && NULL != l_pvPersistentList) { // LCOV_EXCL_BR_LINE 6: f_pvpersistnotification and l_pvPersistentList can't be null // NOLINT[whitespace/line_length] + for (UI_32 l_uiCount = 0; + l_uiCount < l_pvPersistentList->size(); + l_uiCount++) { + // get the persistent notification name from vector + l_cNotificationName = l_pvPersistentList->at(l_uiCount); + + // search for notification in map + l_itNotification = m_pmNotificationList->find(l_cNotificationName); + + // notification found in map + if (m_pmNotificationList->end() != l_itNotification) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Persistent Notification: %s", l_cNotificationName.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + + // get notification object from map + l_pNotification = (*l_itNotification).second; + + if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 6: l_pNotification can't be NULL + if (eFrameworkunifiedPersistedStateVar == f_enotificationtype) { + l_pStatePersistenceNotification = static_cast(l_pNotification); + + // get the notification's default data + if ((eFrameworkunifiedUserData == l_pStatePersistenceNotification->GetPersistentCategory() && + (f_uinotificationpersistentservicepersistcategoryflag & eFrameworkunifiedUserData)) || + (eFrameworkunifiedFactoryData == l_pStatePersistenceNotification->GetPersistentCategory() && + (f_uinotificationpersistentservicepersistcategoryflag & eFrameworkunifiedFactoryData)) || + (eFrameworkunifiedFactoryCustomerData == l_pStatePersistenceNotification->GetPersistentCategory() && + (f_uinotificationpersistentservicepersistcategoryflag & eFrameworkunifiedFactoryCustomerData)) || + (eFrameworkunifiedDealerData == l_pStatePersistenceNotification->GetPersistentCategory() && + (f_uinotificationpersistentservicepersistcategoryflag & eFrameworkunifiedDealerData))) { + l_pPData = l_pStatePersistenceNotification->GetDefaultPersistentData(); + } else { + l_pStateNotification = l_pStatePersistenceNotification; + + // get the published notification data + if (l_pStateNotification->IsPublished()) { + l_pPData = l_pStateNotification->GetPersistentData(); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Notification not published"); + } + } + } else { + l_pStateNotification = static_cast(l_pNotification); + + // if not to reset userdata + if (0 == (f_uinotificationpersistentservicepersistcategoryflag & eFrameworkunifiedUserData)) { + if (l_pStateNotification->IsPublished()) { + l_pPData = l_pStateNotification->GetPersistentData(); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Notification not published"); + } + } + } + + if ((NULL != l_pStateNotification) && (NULL != l_pPData)) { + l_pNotificationsToPersist = CreateNotificationObjectToPersist(l_pStateNotification, l_pPData); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + + // insert the persistent data in map + f_pvpersistnotification->push_back(l_pNotificationsToPersist); // LCOV_EXCL_BR_LINE 11: unexpected branch + + l_pPData = NULL; + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "no data is stored in notification %s", l_cNotificationName.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification object is NULL for %s", l_cNotificationName.c_str()); // LCOV_EXCL_LINE 6: l_pNotification can't be NULL // NOLINT[whitespace/line_length] + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Non Persistent Notification: %s", l_cNotificationName.c_str()); + } + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; // LCOV_EXCL_LINE 6: f_pvpersistnotification and l_pvPersistentList can't be null // NOLINT[whitespace/line_length] + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CreateNotificationObjectToPersist +/// Creates the CNotificationsToPersist object from notification object and the persistent data. +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNotificationsToPersist *CNotificationManager::CreateNotificationObjectToPersist(CStateNotification + *f_pStateNotification, + const CPersistentData *f_pdata) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CNotificationsToPersist *l_pNotificationsToPersist = NULL; + CPersistentData *l_pData = NULL; + + if (NULL != f_pStateNotification && NULL != f_pdata) { // LCOV_EXCL_BR_LINE 6: f_pStateNotification and f_pdata can't be NULL // NOLINT[whitespace/line_length] + if (f_pStateNotification->GetMaxMessageSize() >= f_pdata->m_uiMsgSize) { + l_pNotificationsToPersist = new(std::nothrow) CNotificationsToPersist(); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + + if (NULL != l_pNotificationsToPersist) { // LCOV_EXCL_BR_LINE 5: It's impossible to mock new() function + l_pNotificationsToPersist->m_pPersistentData = new(std::nothrow) CPersistentData(); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + l_pData = l_pNotificationsToPersist->m_pPersistentData; + + if (NULL != l_pData) { // LCOV_EXCL_BR_LINE 5: It's impossible to mock new() function + l_pNotificationsToPersist->m_cNotificationName = f_pStateNotification->GetNotificationName(); + l_pNotificationsToPersist->m_uiMaxMsgLength = f_pStateNotification->GetMaxMessageSize(); + l_pNotificationsToPersist->m_ePersistentType = f_pStateNotification->GetNotificationType(); + + if (eFrameworkunifiedPersistedStateVar == l_pNotificationsToPersist->m_ePersistentType) { + l_pNotificationsToPersist->m_ePersistCategory = (static_cast + (f_pStateNotification))->GetPersistentCategory(); + } + + l_pNotificationsToPersist->m_cPublisherName = f_pStateNotification->GetPublisherName(); + + l_pData->m_uiMsgSize = f_pdata->m_uiMsgSize; + l_pData->m_pMessage = new(std::nothrow) CHAR[l_pNotificationsToPersist->m_uiMaxMsgLength]; + + if (NULL != l_pData->m_pMessage) { // LCOV_EXCL_BR_LINE 5: It's impossible to mock new() function + std::memset(l_pData->m_pMessage, 0, l_pNotificationsToPersist->m_uiMaxMsgLength); + std::memcpy(l_pData->m_pMessage, f_pdata->m_pMessage, f_pdata->m_uiMsgSize); + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "memory not allocated for l_pNotificationsToPersist"); // LCOV_EXCL_LINE 5: It's impossible to mock new() function // NOLINT[whitespace/line_length] + } + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error persisting notfn, Data size of notification %s is %d greater than max registered size %d", + f_pStateNotification->GetNotificationName().c_str(), + f_pdata->m_uiMsgSize, f_pStateNotification->GetMaxMessageSize()); + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid parameter received"); // LCOV_EXCL_LINE 6: f_pStateNotification and f_pdata can't be NULL // NOLINT[whitespace/line_length] + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_pNotificationsToPersist; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceSetPersistentNotificationData +/// This function is used to create the persistent notifications object and fill the data related +/// with it on system load. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceSetPersistentNotificationData(std::vector + *f_pvpersistnotification) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CStateNotification *l_pNotification = NULL; + CNotificationsToPersist *l_pNotificationsToPersist = NULL; + + std::vector *l_pvPersistentList = NULL; + + Persistent_Iterator_Type l_itPersistentData; + + // store all the notification data received in vector to map of CNotification and to vector of + // persistent notification in case of persistent and user persistent notification + if (NULL != f_pvpersistnotification) { // LCOV_EXCL_BR_LINE 6: double check, f_pvpersistnotification can't be NULL + for (UI_32 l_uiCount = 0; + l_uiCount < f_pvpersistnotification->size(); + l_uiCount++) { + // get the persistent data object + l_pNotificationsToPersist = f_pvpersistnotification->at(l_uiCount); + + if (NULL != l_pNotificationsToPersist) { // LCOV_EXCL_BR_LINE 6: double check, l_pNotificationsToPersist can't be NULL // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Persistent Type %d", l_pNotificationsToPersist->m_ePersistentType); + + if (eFrameworkunifiedPersistedStateVar == l_pNotificationsToPersist->m_ePersistentType) { + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "PersistentState Notification"); + + l_pNotification = new(std::nothrow) CStatePersistenceNotification( + l_pNotificationsToPersist->m_cNotificationName, + l_pNotificationsToPersist->m_uiMaxMsgLength, + l_pNotificationsToPersist->m_ePersistCategory); + + l_pvPersistentList = m_pvPersistentList; + } else if (eFrameworkunifiedPersistedStateUserVar == l_pNotificationsToPersist->m_ePersistentType) { + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "PersistentStateUser Notification"); + + l_pNotification = new(std::nothrow) CStatePersistenceUserNotification( + l_pNotificationsToPersist->m_cNotificationName, + l_pNotificationsToPersist->m_uiMaxMsgLength); + + l_pvPersistentList = m_pvUserPersistentList; + } else if (eFrameworkunifiedImmediatePersistedStateVar == l_pNotificationsToPersist->m_ePersistentType) { // LCOV_EXCL_BR_LINE 6: l_pNotificationsToPersist->m_ePersistentType must be eFrameworkunifiedPersistedStateVar, eFrameworkunifiedPersistedStateUserVar, eFrameworkunifiedImmediatePersistedStateVar // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "PersistentStateUser Notification"); + + l_pNotification = new(std::nothrow) CStateNorPersistenceNotification( + l_pNotificationsToPersist->m_cNotificationName, + l_pNotificationsToPersist->m_uiMaxMsgLength, + l_pNotificationsToPersist->m_uiDelay, + l_pNotificationsToPersist->m_ePersistCategory); + } + + if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 6: l_pNotification can't be NULL + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Insert persistent notification object in map"); + + l_pNotification->SetPersistentData(l_pNotificationsToPersist->m_pPersistentData->m_pMessage, + l_pNotificationsToPersist->m_pPersistentData->m_uiMsgSize); + + l_pNotification->SetEventPublisher(l_pNotificationsToPersist->m_cPublisherName); + + if (NULL != m_pmNotificationList) { // LCOV_EXCL_BR_LINE 6: double check, m_pmNotificationList can't be NULL + m_pmNotificationList->insert(make_pair(l_pNotificationsToPersist->m_cNotificationName, l_pNotification)); + + if (NULL != l_pvPersistentList) { + l_pvPersistentList->push_back(l_pNotificationsToPersist->m_cNotificationName); + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Inserted persistent notification object in map"); + } + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Inserted persistent notification object in vector"); + } else { + // LCOV_EXCL_START 6: double check, m_pmNotificationList can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + delete l_pNotification; + l_pNotification = NULL; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification object not inserted in map/vector"); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: l_pNotification can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "notification object is NULL"); + + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: double check, l_pNotificationsToPersist can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pNotificationsToPersist is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } + } else { + // LCOV_EXCL_START 6: double check, f_pvpersistnotification can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistent data pointer is NULL"); + + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// RemoveUserSpecificNotificationEntry +/// This function is used to remove the user persistent notifications entry +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::RemoveUserSpecificNotificationEntry() { // LCOV_EXCL_START 100: never be used + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + std::string l_cNotificationName; + + std::vector::iterator l_itNotificationName; + + // iterator to find notification from map of notifications + Notification_Iterator_Type l_itNotification; + + CNotification *l_pNotification = NULL; + + for (l_itNotificationName = m_pvUserPersistentList->begin() ; l_itNotificationName < m_pvUserPersistentList->end() ; + l_itNotificationName++) { + l_cNotificationName = *(l_itNotificationName); + + // check if this notification's object present in map + l_itNotification = m_pmNotificationList->find(l_cNotificationName); + + if (m_pmNotificationList->end() != l_itNotification) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Notification found in map"); + + // get the notification object pointer from map + l_pNotification = (*l_itNotification).second; + + if (NULL != l_pNotification) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Deleting Notification Object"); + + // delete the notification + delete l_pNotification; + l_pNotification = NULL; + + m_pmNotificationList->erase(l_itNotification); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Deleting Notification name from vector"); + m_pvUserPersistentList->erase(l_itNotificationName); + + l_itNotificationName = m_pvUserPersistentList->begin(); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification not found."); + + l_estatus = eFrameworkunifiedStatusFail; + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} +// LCOV_EXCL_STOP + +EFrameworkunifiedStatus CNotificationManager::GetNotificationInfo(const std::string &f_cnotificationname, // LCOV_EXCL_START 100: never be used // NOLINT[whitespace/line_length] + CNotificationsToPersist *&f_pnotificationstopersist) { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CNotification *l_pNotification = NULL; + CStateNotification *l_pStateNotification = NULL; + const CPersistentData *l_pPData = NULL; + + l_pNotification = SearchNotification(f_cnotificationname); + l_pStateNotification = static_cast(l_pNotification); + + if (NULL != l_pStateNotification) { + if (l_pStateNotification->IsPublished()) { + l_pPData = l_pStateNotification->GetPersistentData(); + + if (NULL != l_pPData) { + f_pnotificationstopersist = new(std::nothrow) CNotificationsToPersist(); + + if (NULL == f_pnotificationstopersist) { + l_estatus = eFrameworkunifiedStatusNullPointer; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Memory allocation error for f_pnotificationstopersist"); + } + + if (eFrameworkunifiedStatusOK == l_estatus) { + f_pnotificationstopersist->m_pPersistentData = new(std::nothrow) CPersistentData(); + + if (NULL == f_pnotificationstopersist->m_pPersistentData) { + l_estatus = eFrameworkunifiedStatusNullPointer; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Memory allocation error for f_pnotificationstopersist->m_pPersistentData"); + } + } + + if (eFrameworkunifiedStatusOK == l_estatus) { + f_pnotificationstopersist->m_cNotificationName = l_pStateNotification->GetNotificationName(); + f_pnotificationstopersist->m_uiMaxMsgLength = l_pStateNotification->GetMaxMessageSize(); + f_pnotificationstopersist->m_cPublisherName = l_pStateNotification->GetPublisherName(); + f_pnotificationstopersist->m_ePersistentType = l_pStateNotification->GetNotificationType(); + + if (eFrameworkunifiedPersistedStateVar == f_pnotificationstopersist->m_ePersistentType) { + f_pnotificationstopersist->m_ePersistCategory = (static_cast + (l_pStateNotification))->GetPersistentCategory(); + } + + if (eFrameworkunifiedImmediatePersistedStateVar == f_pnotificationstopersist->m_ePersistentType) { + CStateNorPersistenceNotification *l_pStateNorPersistenceNotification = + static_cast(l_pStateNotification); + f_pnotificationstopersist->m_uiDelay = l_pStateNorPersistenceNotification->GetPersistenceDelay(); + f_pnotificationstopersist->m_ePersistCategory = (static_cast + (l_pStateNotification))->GetPersistentCategory(); + } + + f_pnotificationstopersist->m_pPersistentData->m_pMessage = new(std::nothrow) + CHAR[f_pnotificationstopersist->m_uiMaxMsgLength]; + std::memset(f_pnotificationstopersist->m_pPersistentData->m_pMessage, 0, + f_pnotificationstopersist->m_uiMaxMsgLength); + std::memcpy(f_pnotificationstopersist->m_pPersistentData->m_pMessage, + l_pPData->m_pMessage, l_pPData->m_uiMsgSize); + + f_pnotificationstopersist->m_pPersistentData->m_uiMsgSize = l_pPData->m_uiMsgSize; + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "No data is stored in notification %s", f_cnotificationname.c_str()); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Notification %s not published", f_cnotificationname.c_str()); + } + } else { + l_estatus = eFrameworkunifiedStatusNullPointer; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceSetDefaultPersistentNotificationData +/// This function is used to set the default data of persistent notification +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceSetDefaultPersistentNotificationData(const std::string &f_cnotificationname, + PVOID f_pmessage, + const UI_32 f_uimsgsize) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // pointer of notification object + CStateNotification *l_pStateNotification = SearchPersistenceNotification(f_cnotificationname); + + if (NULL != l_pStateNotification) { + l_estatus = l_pStateNotification->SetDefaultPersistentData(f_pmessage, f_uimsgsize); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to set default notification data for %s, notification does not exists", + f_cnotificationname.c_str()); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceSetPersistentCategory +/// This function is used to set the persistent type of persistent notification +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceSetPersistentCategory(const std::string &f_cnotificationname, + const EFrameworkunifiedPersistCategory f_epersistcategory) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // pointer of notification object + CStateNotification *l_pStateNotification = SearchPersistenceNotification(f_cnotificationname); + + if (NULL != l_pStateNotification) { + EFrameworkunifiedNotificationType l_eNotificationType = l_pStateNotification->GetNotificationType(); + + if (eFrameworkunifiedPersistedStateVar == l_eNotificationType) { + l_estatus = (static_cast(l_pStateNotification))->SetPersistentCategory( + f_epersistcategory); + } else if (eFrameworkunifiedImmediatePersistedStateVar == l_eNotificationType) { + l_estatus = (static_cast(l_pStateNotification))->SetPersistentCategory( + f_epersistcategory); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Cannot set category %d for notification %s of type %d", f_epersistcategory, + f_cnotificationname.c_str(), l_eNotificationType); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Cannot set category %d for %s, Either not registered or not a persistent notification", + f_epersistcategory, f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentservicePublishImmediateNotification +/// This function publish the immediate notification f_cnotificationname to all its subscribers. +/// This API is called when service updates the immediate notification data in persistent memory +/// using synchronous API. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CNotificationManager::NotificationpersistentservicePublishImmediateNotification(const std::string &f_cservicename, + const std::string &f_cnotificationname, + PVOID f_pmessage, + const UI_32 f_uimsgsize) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (f_cservicename.empty() || f_cnotificationname.empty()) { + l_estatus = eFrameworkunifiedStatusInvldParam; + } else { + // get the notification object from map + CStateNotification *l_pStateNotf = SearchPersistenceNotification(f_cnotificationname); + + if (NULL != l_pStateNotf) { + if (eFrameworkunifiedImmediatePersistedStateVar == l_pStateNotf->GetNotificationType()) { + CStateNorPersistenceNotification *l_pImmediateNotf = + static_cast(l_pStateNotf); + + // publish the notification + if (eFrameworkunifiedStatusOK != (l_estatus = l_pImmediateNotf->PublishNotification(f_cservicename, + f_pmessage, + f_uimsgsize))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error publishing notification %s published by %s, status: %d", + f_cnotificationname.c_str(), f_cservicename.c_str(), l_estatus); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s is not registered as immediate persistence by service %s", + f_cnotificationname.c_str(), f_cservicename.c_str()); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s not registered by service %s", f_cnotificationname.c_str(), + f_cservicename.c_str()); + + l_estatus = eFrameworkunifiedStatusNullPointer; + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +#ifdef NPP_PROFILEINFO_ENABLE + +EFrameworkunifiedStatus CNotificationManager::GetNotificationProfilingData(std::string &f_cnotificationprofileInfo) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + Notification_Iterator_Type l_itNotification; + NotifReceiver_Iterator_Type l_itNotifReceiver_Iterator; + + CNotification *l_pNotification = NULL; + NotifReceiver_Type *l_pSubscriberList = NULL; + + std::stringstream ss; + UI_32 l_uiSubscriberCnt = 0; + + std::string l_cPublisher = ""; + std::string l_cNotification = ""; + + try { + if (NULL == m_pmNotificationList) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification List m_pmNotificationList is NULL in notification manager"); + l_estatus = eFrameworkunifiedStatusFail; + } + + if (eFrameworkunifiedStatusOK == l_estatus && m_pmNotificationList->empty()) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification List m_pmNotificationList Empty in notification manager"); + l_estatus = eFrameworkunifiedStatusFail; + } + + if (eFrameworkunifiedStatusOK == l_estatus) { + f_cnotificationprofileInfo.append("Application Name,"); + f_cnotificationprofileInfo.append("Notification Name,"); + f_cnotificationprofileInfo.append("Type,"); + f_cnotificationprofileInfo.append("Length,"); + f_cnotificationprofileInfo.append("Subscribed By,"); + f_cnotificationprofileInfo.append("Subscribers Count"); + + for (l_itNotification = m_pmNotificationList->begin(); + l_itNotification != m_pmNotificationList->end(); + l_itNotification++) { + l_pNotification = (*l_itNotification).second; + if (NULL == l_pNotification) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification object ptr is NULL"); + l_estatus = eFrameworkunifiedStatusFail; + } else { + l_cPublisher = l_pNotification->GetPublisherName(); + if (l_cPublisher.empty()) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Publisher name empty"); + l_estatus = eFrameworkunifiedStatusFail; + } + + l_cNotification = l_pNotification->GetNotificationName(); + if (l_cNotification.empty()) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification name empty"); + l_estatus = eFrameworkunifiedStatusFail; + } + + l_pSubscriberList = l_pNotification->GetSubscriberList(); + if (NULL == l_pSubscriberList) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Subscribers List ptr is NULL"); + l_estatus = eFrameworkunifiedStatusFail; + } + } + + if (eFrameworkunifiedStatusOK == l_estatus) { + f_cnotificationprofileInfo.append("\n"); + + f_cnotificationprofileInfo.append(l_cPublisher); + f_cnotificationprofileInfo.append(","); + + f_cnotificationprofileInfo.append(l_cNotification); + f_cnotificationprofileInfo.append(","); + + switch (l_pNotification->GetNotificationType()) { + case eFrameworkunifiedNotificationVar : { + f_cnotificationprofileInfo.append("Regular"); + } + break; + + case eFrameworkunifiedStateVar : { + f_cnotificationprofileInfo.append("State"); + } + break; + + case eFrameworkunifiedPersistedStateVar : { + f_cnotificationprofileInfo.append("PersistenceState"); + } + break; + + case eFrameworkunifiedPersistedStateUserVar : { + f_cnotificationprofileInfo.append("UserPersistenceState"); + } + break; + + case eFrameworkunifiedImmediatePersistedStateVar : { + f_cnotificationprofileInfo.append("ImmediatePersistenceState"); + } + break; + + case eFrameworkunifiedUnknown: { + f_cnotificationprofileInfo.append("Unknown"); + } + break; + + default: + break; + } + f_cnotificationprofileInfo.append(","); + + ss << l_pNotification->GetMaxMessageSize(); + f_cnotificationprofileInfo.append(ss.str()); + ss.str(""); + f_cnotificationprofileInfo.append(",\""); + + l_uiSubscriberCnt = 0; + for (l_itNotifReceiver_Iterator = l_pSubscriberList->begin(); + l_pSubscriberList->end() != l_itNotifReceiver_Iterator;) { + f_cnotificationprofileInfo.append(l_itNotifReceiver_Iterator->first); + ++l_uiSubscriberCnt; + + ++l_itNotifReceiver_Iterator; + + if (l_pSubscriberList->end() != l_itNotifReceiver_Iterator) { + f_cnotificationprofileInfo.append(","); + } + } + + f_cnotificationprofileInfo.append("\","); + + ss << l_uiSubscriberCnt; + f_cnotificationprofileInfo.append(ss.str()); + ss.str(""); + } + + l_estatus = eFrameworkunifiedStatusOK; + } + } + } catch (std::exception &exp) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Exception:: %s", exp.what()); + l_estatus = eFrameworkunifiedStatusFail; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +#endif diff --git a/service/native/notification_persistent_service/server/src/ns_npp_notification_receiver.cpp b/service/native/notification_persistent_service/server/src/ns_npp_notification_receiver.cpp new file mode 100755 index 0000000..53b9eab --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_notification_receiver.cpp @@ -0,0 +1,50 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CNotificationReceiver. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include "ns_npp_notification_receiver.h" + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CNotificationReceiver +/// Constructor of CNotificationReceiver class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNotificationReceiver::CNotificationReceiver() { + m_MsgQHandle = NULL; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CNotificationReceiver +/// Destructor of CNotificationReceiver class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CNotificationReceiver::~CNotificationReceiver() { + m_MsgQHandle = NULL; +} + diff --git a/service/native/notification_persistent_service/server/src/ns_npp_persist_file.cpp b/service/native/notification_persistent_service/server/src/ns_npp_persist_file.cpp new file mode 100755 index 0000000..4b0e452 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_persist_file.cpp @@ -0,0 +1,100 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NPPService +/// \brief The file contains definition of CFilePersistence class. +/// This class is responsible for persisting and retrieving of files. +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include +#include +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_copy_worker.h" +#include "ns_npp_persist_file.h" +#include "ns_npp_registry_entry.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CFilePersistence +/// Constructor of CFilePersistence class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CFilePersistence::CFilePersistence() { +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CFilePersistence +/// Destructor of CFilePersistence class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CFilePersistence::~CFilePersistence() { // LCOV_EXCL_START 14: Resident process, global instance not released + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// Release +/// Entry for the file is stored in map for persistence. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CFilePersistence::Release(std::string f_crequesterappname, + std::string f_ctag, + std::string f_cmempath, + EFrameworkunifiedReleaseType enotificationpersistentservicereleasetype, + std::string f_cusername) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (f_cmempath.empty() || f_crequesterappname.empty() || f_ctag.empty()) { // LCOV_EXCL_BR_LINE 6: double check, f_cmempath, f_crequesterappname and f_ctag can't be empty + // LCOV_EXCL_START 6: f_cmempath, f_crequesterappname and f_ctag can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid file path, requester or tag."); + l_estatus = eFrameworkunifiedStatusInvldParam; + // LCOV_EXCL_STOP + } else { + l_estatus = ProcessReleaseRequest(f_crequesterappname, f_ctag, ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE, f_cmempath, enotificationpersistentservicereleasetype, + f_cusername); // LCOV_EXCL_BR_LINE 11: unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "- l_estatus:0x%x", l_estatus); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// Load +/// Load file from persistent memory to the specified location. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CFilePersistence::Load(std::string f_crequesterappname, + std::string f_ctag, + std::string f_cretrievepath, + std::string f_cusername) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + + if (!f_ctag.empty() && !f_crequesterappname.empty() && !f_cretrievepath.empty()) { // LCOV_EXCL_BR_LINE 6: double check, f_ctag, f_crequesterappname and f_cretrievepath can't be empty + l_estatus = ProcessLoadRequest(f_crequesterappname, f_ctag, ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE, f_cretrievepath, f_cusername); // LCOV_EXCL_BR_LINE 11: unexpected branch + } else { + // LCOV_EXCL_START 6: f_ctag, f_crequesterappname and f_cretrievepath can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid argument passed (RetrievePath:%s ,tag:%s, requester:%s)", + f_cretrievepath.c_str(), f_ctag.c_str(), f_crequesterappname.c_str()); + + l_estatus = eFrameworkunifiedStatusInvldParam; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} diff --git a/service/native/notification_persistent_service/server/src/ns_npp_persist_folder.cpp b/service/native/notification_persistent_service/server/src/ns_npp_persist_folder.cpp new file mode 100755 index 0000000..87b1ed4 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_persist_folder.cpp @@ -0,0 +1,96 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include "ns_npp_persistence.h" +#include "ns_npp_persist_folder.h" +#include "ns_npp_registry_entry.h" + +// Constructor of class CFolderPersistence +CFolderPersistence::CFolderPersistence() { +} + +// Destructor of class CFolderPersistence +CFolderPersistence::~CFolderPersistence() { // LCOV_EXCL_START 14: Resident process, global instance not released + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert +} +// LCOV_EXCL_STOP + +// Method to release folder for persistence. +EFrameworkunifiedStatus CFolderPersistence::Release(std::string f_crequesterappname, + std::string f_ctag, + std::string f_cmempath, + EFrameworkunifiedReleaseType enotificationpersistentservicereleasetype, + std::string f_cusername) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (f_cmempath.empty() || f_crequesterappname.empty() || f_ctag.empty()) { // LCOV_EXCL_BR_LINE 6: double check, f_cmempath, f_crequesterappname and f_ctag can't be empty // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: f_ctag, f_crequesterappname and f_cmempath can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid folder path, requester or tag."); + l_estatus = eFrameworkunifiedStatusInvldParam; + // LCOV_EXCL_STOP + } else { + // Call to method requesting to release the folder for persistence. + l_estatus = ProcessReleaseRequest(f_crequesterappname, f_ctag, ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER, f_cmempath, enotificationpersistentservicereleasetype, + f_cusername); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "- l_estatus:0x%x", l_estatus); + return l_estatus; +} + +// Method to load folder from persistent memory. +EFrameworkunifiedStatus CFolderPersistence::Load(std::string f_crequesterappname, + std::string f_ctag, + std::string f_cretrievepath, + std::string f_cusername) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + + if (!f_ctag.empty() && !f_crequesterappname.empty() && !f_cretrievepath.empty()) { // LCOV_EXCL_BR_LINE 6: double check, f_cretrievepath, f_crequesterappname and f_ctag can't be empty // NOLINT[whitespace/line_length] + // Call to method requesting to load the folder from persistent memory. + l_estatus = ProcessLoadRequest(f_crequesterappname, f_ctag, ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER, f_cretrievepath, f_cusername); + } else { + // LCOV_EXCL_START 6: f_ctag, f_crequesterappname and f_cretrievepath can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid argument passed (RetrievePath:%s ,tag:%s, requester:%s)", + f_cretrievepath.c_str(), f_ctag.c_str(), f_crequesterappname.c_str()); + + l_estatus = eFrameworkunifiedStatusInvldParam; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} diff --git a/service/native/notification_persistent_service/server/src/ns_npp_persistence.cpp b/service/native/notification_persistent_service/server/src/ns_npp_persistence.cpp new file mode 100755 index 0000000..a39b836 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_persistence.cpp @@ -0,0 +1,743 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CPersistence. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#ifdef AGL_STUB +#include +// #include "frameworkunified_stub.h" +#endif +#include +#include // for getenv() +#ifdef AGL_STUB +#include +#endif +#include +#include +#include "ns_npp_persistence.h" +#include "ns_npp_registry_entry.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CPersistence +/// Constructor of CPersistence class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CPersistence::CPersistence(): + m_cStoragePath(GetStoragePath()), + m_eCompressionType(ENOTIFICATIONPERSISTENTSERVICEDEFAULTCOMPRESSION), + m_hNSWriteToPersistentMem(NULL), + m_hNSReadFromPersistentMem(NULL), + m_hAppHandle(NULL), + m_bPersist(FALSE), + m_uiNotificationpersistentservicePersistCategoryFlag(0) { +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CPersistence +/// Destructor of CPersistence class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CPersistence::~CPersistence() { // LCOV_EXCL_START 14: Resident process, global instance not released + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SetReadThreadHandle +/// Set read thread handle. +//////////////////////////////////////////////////////////////////////////////////////////////////// +VOID CPersistence::SetReadThreadHandle(HANDLE f_hreadthread) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + m_hNSReadFromPersistentMem = f_hreadthread; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SetWriteThreadHandle +/// Set write thread handle. +//////////////////////////////////////////////////////////////////////////////////////////////////// +VOID CPersistence::SetWriteThreadHandle(HANDLE f_hwritethread) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + m_hNSWriteToPersistentMem = f_hwritethread; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// GetStoragePath +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +std::string CPersistence::GetStoragePath() { + std::string l_cStoragePath(STORAGE_PATH); + + return l_cStoragePath; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// Register +/// Register tag for persistence. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistence::Register(std::string f_crequestorappname, std::string f_ctag, BOOL bisuserpersistence) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + if (f_ctag.empty() || f_crequestorappname.empty()) { // LCOV_EXCL_BR_LINE 6: f_ctag and f_crequestorappname can't be empty // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: f_ctag and f_crequestorappname can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid tag or requester."); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } else { + TSourceRegistryListItr l_itRegistry = m_mPersistRegistry.find(f_crequestorappname); + if (l_itRegistry != m_mPersistRegistry.end()) { + // source available, check for file/folder availability + TTagRegistryListItr l_itRegistryList = (l_itRegistry->second).find(f_ctag); + if (l_itRegistryList != (l_itRegistry->second).end()) { + // found already in the registry + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Already exists %s , %s", f_ctag.c_str(), f_crequestorappname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } else { + // tag not found .. so add to the registry + CRegistryEntry l_objRegistryEntry(f_ctag, f_crequestorappname, m_cStoragePath, + bisuserpersistence); // f_eRegisterType, f_cUser); + + (l_itRegistry->second).insert(make_pair(f_ctag, l_objRegistryEntry)); + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %s found adding tag %s", f_crequestorappname.c_str(), f_ctag.c_str()); + } + } else { + // source not found, so creating a new entry + CRegistryEntry l_objRegistryEntry(f_ctag, f_crequestorappname, m_cStoragePath, + bisuserpersistence); // f_eRegisterType, f_cUser); + + TTagRegistryList l_mRegList; + l_mRegList.insert(make_pair(f_ctag, l_objRegistryEntry)); // LCOV_EXCL_BR_LINE 11:except,C++ STL + + m_mPersistRegistry.insert(std::make_pair(f_crequestorappname, l_mRegList)); // LCOV_EXCL_BR_LINE 11:except,C++ STL // NOLINT[whitespace/line_length] + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "none exists %s , %s. So, added entry.", // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + f_ctag.c_str(), f_crequestorappname.c_str()); // LCOV_EXCL_BR_LINE 11: unexpected branch + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "- l_estatus:0x%x", l_estatus); + + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ProcessReleaseRequest +/// Persist file/folder that need to be persisted. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistence::ProcessReleaseRequest(std::string f_crequesterappname, + std::string f_ctag, + ENotificationpersistentservicePersistType f_epersisttype, + std::string f_cmempath, + EFrameworkunifiedReleaseType enotificationpersistentservicereleasetype, + std::string f_cusername) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (f_cmempath.empty() || f_crequesterappname.empty() || f_ctag.empty()) { // LCOV_EXCL_BR_LINE 6:f_cmempath, f_crequesterappname and f_ctag can`t be empty // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: f_cmempath, f_crequesterappname and f_ctag can`t be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG0(ZONE_ERR, __FUNCTION__, "Invalid file path, requester or tag."); + l_estatus = eFrameworkunifiedStatusInvldParam; + // LCOV_EXCL_STOP + } else { + // Persistence Registry map iterator + TSourceRegistryListItr l_itTSourceRegistryListItr = m_mPersistRegistry.find(f_crequesterappname); + + if (l_itTSourceRegistryListItr != m_mPersistRegistry.end()) { + // source available, check for file if registered + TTagRegistryListItr l_itTRegistryList = (l_itTSourceRegistryListItr->second).find(f_ctag); + if (l_itTRegistryList != (l_itTSourceRegistryListItr->second).end()) { + if (eFrameworkunifiedNotOnRelease != enotificationpersistentservicereleasetype) { + // Set release path + l_itTRegistryList->second.SetReleasePath(f_cmempath); + // Set persist path + l_itTRegistryList->second.SetPersistProperties(f_epersisttype, f_cusername); // LCOV_EXCL_BR_LINE 11:except,C++ STL // NOLINT[whitespace/line_length] + + // file/folder found in registry + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + "%s released %s. Found in registry. queued up to persist from %s", + f_crequesterappname.c_str(), f_ctag.c_str(), l_itTRegistryList->second.GetReleasePath().c_str()); + + // check if persist flag is set due to shutdown or user change + if ((m_bPersist // It will be set to TRUE either on shutdown or userchange + && l_itTRegistryList->second.HasntBeenPersisted()) // File/Folder persisted or not + || (eFrameworkunifiedPersistInstantly == enotificationpersistentservicereleasetype)) { + // reset the data + if (((eFrameworkunifiedUserData == l_itTRegistryList->second.GetPersistentCategory()) && + (eFrameworkunifiedUserData & m_uiNotificationpersistentservicePersistCategoryFlag)) || + ((eFrameworkunifiedFactoryData == l_itTRegistryList->second.GetPersistentCategory()) && + (eFrameworkunifiedFactoryData & m_uiNotificationpersistentservicePersistCategoryFlag)) || + ((eFrameworkunifiedFactoryCustomerData == l_itTRegistryList->second.GetPersistentCategory()) && + (eFrameworkunifiedFactoryCustomerData & m_uiNotificationpersistentservicePersistCategoryFlag)) || + ((eFrameworkunifiedDealerData == l_itTRegistryList->second.GetPersistentCategory()) && + (eFrameworkunifiedDealerData & m_uiNotificationpersistentservicePersistCategoryFlag))) { + // set the status of file/folder persisted as reset has been called on these data + l_itTRegistryList->second.SetCurrentAction(LOADTYPE_RELEASE); + l_itTRegistryList->second.SetBeingPersisted(); + } else { // persist the data + if (eFrameworkunifiedStatusOK != (l_estatus = Persist(static_cast(l_itTRegistryList->second)))) { // LCOV_EXCL_BR_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; // LCOV_EXCL_LINE 4: NSFW error case. + } + } + } else { + // Don't persist now. Persist on shutdown. + } + } else { // not on release + // set the status of file/folder as released and persisted as these data need not to be persisted on shutdown + l_itTRegistryList->second.SetReleasePath(""); + l_itTRegistryList->second.SetCurrentAction(LOADTYPE_RELEASE); + l_itTRegistryList->second.SetBeingPersisted(); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Warning: %s didn't register %s, not persisting", + f_crequesterappname.c_str(), f_ctag.c_str()); // LCOV_EXCL_BR_LINE 11: unexpected branch + l_estatus = eFrameworkunifiedStatusInvldParam; + } + } else { + // source not registered, cannot persist + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Warning: %s is not registered ignoring release of %s", + f_ctag.c_str(), f_crequesterappname.c_str()); + l_estatus = eFrameworkunifiedStatusInvldParam; + } + } + return l_estatus; +} + +EFrameworkunifiedStatus CPersistence::Persist(CRegistryEntry &f_objregistryentry) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + // Persistence Info Structure + NSP_CopyInfoCmd l_tCpInfo = {}; + + + std::string l_cSourcePath = f_objregistryentry.GetReleasePath(); + std::string l_cPersistPath = f_objregistryentry.GetPersistPath(); // LCOV_EXCL_BR_LINE 11:except,C++ STL + + // Fill the persistence info structure + AddRequestData(l_tCpInfo, + l_cSourcePath, + l_cPersistPath, + f_objregistryentry.GetRequester(), + f_objregistryentry.GetTag(), + LOADTYPE_RELEASE, + f_objregistryentry.GetPersistType()); + + // Persist only if file was released. + // Release means application has asked NPPService to persist file at shutdown.) + // Persist means actual persisting a file at persistent storage + if (f_objregistryentry.IsReleased()) { + if (ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATEINPROCESS == f_objregistryentry.m_eJobState) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Another job with source: %s and tag %s is in process. " + "Therefore adding release request to the pending queue.", + f_objregistryentry.GetRequester().c_str(), f_objregistryentry.GetTag().c_str()); + // if job corresponding to the tag is already in process, add it in pending queue + m_lPendingJobs.push_back(l_tCpInfo); + } else if (ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATEIDLE == f_objregistryentry.m_eJobState) { + if (eFrameworkunifiedStatusOK == (SendRequestMessage(l_tCpInfo))) { // LCOV_EXCL_BR_LINE 4: NSFW error case. + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Release message passed to writer thread."); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + f_objregistryentry.SetCurrentAction(LOADTYPE_RELEASE); + f_objregistryentry.m_eJobState = ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATEINPROCESS; + } else { + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Failure in passing release message to writer thread."); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "File/Folder not released yet."); + } + + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ProcessLoadRequest +/// Load persisted file/folder. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistence::ProcessLoadRequest(std::string f_crequesterappname, + std::string f_ctag, + ENotificationpersistentservicePersistType f_epersisttype, + std::string f_cretrievepath, + std::string f_cusername) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + // file/folder found in registry + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, + "Load request received: Requester: %s and Tag: %s Load at: %s.", + f_crequesterappname.c_str(), f_ctag.c_str(), f_cretrievepath.c_str()); // LCOV_EXCL_BR_LINE 11:except,C++ STL + + if (f_ctag.empty() || f_crequesterappname.empty() || f_cretrievepath.empty()) { // LCOV_EXCL_BR_LINE 6: both f_ctag and f_crequesterappname and f_cretrievepath can`t be empty // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: both f_ctag and f_crequesterappname and f_cretrievepath can`t be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid argument passed (RetrievePath:%s ,tag:%s, requester:%s)", + f_cretrievepath.c_str(), f_ctag.c_str(), f_crequesterappname.c_str()); + l_estatus = eFrameworkunifiedStatusInvldParam; + // LCOV_EXCL_STOP + } else { + // Persistence Registry Map Iterator + TSourceRegistryListItr l_itTRegistry = m_mPersistRegistry.find(f_crequesterappname); + + // Persistence Info Struct + NSP_CopyInfoCmd l_tCopyInfo = {}; + + if (l_itTRegistry != m_mPersistRegistry.end()) { + // source available, check for file/folder + TTagRegistryListItr l_itTRegistryList = (l_itTRegistry->second).find(f_ctag); + if (l_itTRegistryList != (l_itTRegistry->second).end()) { + if ((ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATERELEASEABORTED == l_itTRegistryList->second.m_eJobState)) { // LCOV_EXCL_BR_LINE 6: m_eJobState can`t be ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATERELEASEABORTED // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 6: m_eJobState can`t be ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATERELEASEABORTED // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + std::string l_cReleasePath(l_itTRegistryList->second.GetReleasePath()); + // if job was aborted due to some reason like abort shutdown. + // Then persistent storage doesn't have updated file/folder. Just restore + // aborted released file. + // just rename it + if (0 == std::rename(l_cReleasePath.c_str(), f_cretrievepath.c_str())) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "File loaded at requested location."); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error while processing load request when tried to move. source: %s dest: %s", + l_cReleasePath.c_str(), f_cretrievepath.c_str()); + l_estatus = eFrameworkunifiedStatusFail; + } + l_itTRegistryList->second.m_eJobState = ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATEIDLE; + // LCOV_EXCL_STOP + } else { + std::string l_cLoadPath(l_itTRegistryList->second.GetLoadPath(f_epersisttype, f_cusername)); // LCOV_EXCL_BR_LINE 11:except,C++ STL // NOLINT[whitespace/line_length] + + if (0 == access(l_cLoadPath.c_str(), R_OK)) { + // file/folder found in registry + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Found in registry. checking in persistence...(%s)", l_cLoadPath.c_str()); + + AddRequestData(l_tCopyInfo, + l_cLoadPath, + f_cretrievepath, + f_crequesterappname, + f_ctag, + LOADTYPE_LOAD, + f_epersisttype); + + if (ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATEINPROCESS == (l_itTRegistryList->second).m_eJobState) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Another job with source: %s and tag %s is in process. " + "Therefore adding load request to the pending queue.", + f_crequesterappname.c_str(), f_ctag.c_str()); + m_lPendingJobs.push_back(l_tCopyInfo); + } else if (ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATEIDLE == (l_itTRegistryList->second).m_eJobState) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Found in persistence."); + if (eFrameworkunifiedStatusOK == (SendRequestMessage(l_tCopyInfo))) { // LCOV_EXCL_BR_LINE 4: NSFW error case. + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Load message passed to reader thread. Retrieving.."); + // file/folder is requested for loading so reset the persisted flag. + l_itTRegistryList->second.ResetPersistedFlag(); + l_itTRegistryList->second.SetCurrentAction(LOADTYPE_LOAD); + l_itTRegistryList->second.m_eJobState = ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATEINPROCESS; + } else { + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Failure in passing load message to reader thread."); + l_estatus = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "%s requested by %s. Not found in persistence memory.", // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + f_ctag.c_str(), f_crequesterappname.c_str()); // LCOV_EXCL_BR_LINE 11:except,C++ STL + l_estatus = eFrameworkunifiedStatusAccessError; + } + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Warning: %s requesting %s .. Tag not found", + f_crequesterappname.c_str(), f_ctag.c_str()); // LCOV_EXCL_BR_LINE 11:except,C++ STL + l_estatus = eFrameworkunifiedStatusFail; + } + } else { + // source not found + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Warning: %s requesting %s .. Requester not found", + f_crequesterappname.c_str(), f_ctag.c_str()); + l_estatus = eFrameworkunifiedStatusFail; + } + } + return l_estatus; +} + +VOID CPersistence::AddRequestData(NSP_CopyInfoCmd &f_tcpinfo, + std::string f_sourcepath, + std::string f_destpath, + std::string f_crequesterappname, + std::string f_ctag, + ENPS_Loadtype f_eloadtype, + ENotificationpersistentservicePersistType f_epersisttype) { +#ifdef AGL_PosixBasedOS001LEGACY_USED + strlcpy(f_tcpinfo.m_csourcepath, f_sourcepath.c_str(), sizeof(f_tcpinfo.m_csourcepath)); + strlcpy(f_tcpinfo.m_cdestinationpath, f_destpath.c_str(), sizeof(f_tcpinfo.m_cdestinationpath)); + strlcpy(f_tcpinfo.m_crequesterappname, f_crequesterappname.c_str(), sizeof(f_tcpinfo.m_crequesterappname)); + strlcpy(f_tcpinfo.m_cpersistenttag, f_ctag.c_str(), sizeof(f_tcpinfo.m_cpersistenttag)); +#endif + f_tcpinfo.m_eloadtype = f_eloadtype; + f_tcpinfo.m_epersisttype = f_epersisttype; + // f_tcpinfo.m_eCompressionType = ENOTIFICATIONPERSISTENTSERVICECOMPRESSUSINGLIBZ; +} + +EFrameworkunifiedStatus CPersistence::SendRequestMessage(NSP_CopyInfoCmd &f_tcpinfo) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + HANDLE l_hThreadHandle = NULL; + // Worker Command Protocol + ENSP_CopyWorkerProtocol l_eWorkerProtocol = CP_WRK_CMD_COPY; + + if (ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE == f_tcpinfo.m_epersisttype) { + l_eWorkerProtocol = CP_WRK_CMD_COPY; + } else if (ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER == f_tcpinfo.m_epersisttype) { + l_eWorkerProtocol = AR_CMD_ARCHIVE; + } + + if (LOADTYPE_RELEASE == f_tcpinfo.m_eloadtype) { + l_hThreadHandle = m_hNSWriteToPersistentMem; + } else if (LOADTYPE_LOAD == f_tcpinfo.m_eloadtype) { + l_hThreadHandle = m_hNSReadFromPersistentMem; + } + + if (l_hThreadHandle) { + // issue a copy to the worker thread + if (eFrameworkunifiedStatusOK != (l_estatus = McSend(l_hThreadHandle, AppName, l_eWorkerProtocol, sizeof(NSP_CopyInfoCmd), &f_tcpinfo))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "McSend for thread failed %d", l_estatus); // LCOV_EXCL_LINE 4: NSFW error case. + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// AckReceivedFromWorker +/// This is callback function for ack that file is released to persistenet memory. +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistence::AckReceivedFromWorker(PCSTR f_csource, PCSTR f_ctag, BOOL f_bcopystatus, + ENPS_Loadtype f_eloadtype) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus retVal = eFrameworkunifiedStatusOK; + + std::string l_cRequester(f_csource); + std::string l_cTag(f_ctag); // LCOV_EXCL_BR_LINE 11:except,C++ STL + + TSourceRegistryListItr l_itTReg = m_mPersistRegistry.find(l_cRequester); + if (l_itTReg != m_mPersistRegistry.end()) { + // source available, check for file + TTagRegistryListItr l_itTRegList = (l_itTReg->second).find(l_cTag); + if (l_itTRegList != (l_itTReg->second).end()) { + if (LOADTYPE_RELEASE == f_eloadtype) { + l_itTRegList->second.SetBeingPersisted(); // LCOV_EXCL_BR_LINE 11: unexpected branch + + if (f_bcopystatus) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "File persisted %s / %s", f_csource, f_ctag); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" + "File not persisted %s / %s, Negative ack received from copy worker thread", + f_csource, + f_ctag); // LCOV_EXCL_BR_LINE 11:except,C++ STL + } + } + + // Job processed. Set job state as idle + l_itTRegList->second.m_eJobState = ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATEIDLE; + + // check if there are any pending jobs for corresponding source and tag + if (!m_lPendingJobs.empty()) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Retrieving next pending job for persistence..."); + TPendingJobsItr l_itrPendingJobs; + for (l_itrPendingJobs = m_lPendingJobs.begin(); l_itrPendingJobs != m_lPendingJobs.end(); ++l_itrPendingJobs) { + if (0 == std::strcmp((*l_itrPendingJobs).m_crequesterappname, f_csource) + && (0 == std::strcmp((*l_itrPendingJobs).m_cpersistenttag, f_ctag))) { + if (eFrameworkunifiedStatusOK == (retVal = (SendRequestMessage((*l_itrPendingJobs))))) { // LCOV_EXCL_BR_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + // set job state as processing + l_itTRegList->second.m_eJobState = ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATEINPROCESS; + // set current action + l_itTRegList->second.SetCurrentAction((*l_itrPendingJobs).m_eloadtype); + // Reset persisted flag. It requires to process release request for this tag. + // Because, file will be persisted only once. Unless, anyone loads the file again. + if (LOADTYPE_LOAD == (*l_itrPendingJobs).m_eloadtype) { + l_itTRegList->second.ResetPersistedFlag(); + } + + // remove job from pending list + m_lPendingJobs.erase(l_itrPendingJobs); + } else { + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Failure in passing load/release message to the worker threads."); + retVal = eFrameworkunifiedStatusFail; + // LCOV_EXCL_STOP + } + + break; + } + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "No pending jobs"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + } else { + // tag not found .. + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " ERROR %s, tag %s not found ", f_csource, f_ctag); + } + } else { + // source not found + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "ERROR none exists %s , %s", f_csource, f_ctag); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return retVal; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// PersistAllReleaseRequests +/// Persist all files which are not persisted yet. +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistence::PersistAllReleaseRequests(UI_32 f_uinotificationpersistentservicepersistcategoryflag) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + m_bPersist = TRUE; // set to true because persist of all release requests have been triggered. + // Trigger reason: shutdown + + m_uiNotificationpersistentservicePersistCategoryFlag = f_uinotificationpersistentservicepersistcategoryflag; + + TSourceRegistryListItr l_itTReg = m_mPersistRegistry.begin(); + + for (; l_itTReg != m_mPersistRegistry.end(); ++l_itTReg) { + TTagRegistryListItr l_itTRegList = (l_itTReg->second).begin(); + for (; l_itTRegList != (l_itTReg->second).end(); ++l_itTRegList) { + if (l_itTRegList->second.HasntBeenPersisted()) { + // reset the data + if (((eFrameworkunifiedUserData == l_itTRegList->second.GetPersistentCategory()) && + (eFrameworkunifiedUserData & f_uinotificationpersistentservicepersistcategoryflag)) || + ((eFrameworkunifiedFactoryData == l_itTRegList->second.GetPersistentCategory()) && + (eFrameworkunifiedFactoryData & f_uinotificationpersistentservicepersistcategoryflag)) || + ((eFrameworkunifiedFactoryCustomerData == l_itTRegList->second.GetPersistentCategory()) && + (eFrameworkunifiedFactoryCustomerData & f_uinotificationpersistentservicepersistcategoryflag)) || + ((eFrameworkunifiedDealerData == l_itTRegList->second.GetPersistentCategory()) && + (eFrameworkunifiedDealerData & f_uinotificationpersistentservicepersistcategoryflag))) { + // set the status of file/folder as released and persisted as these data need not to be persisted on shutdown + l_itTRegList->second.SetCurrentAction(LOADTYPE_RELEASE); + l_itTRegList->second.SetBeingPersisted(); + } else { // persist the data + if (eFrameworkunifiedStatusOK != Persist(static_cast(l_itTRegList->second))) { // LCOV_EXCL_BR_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; // LCOV_EXCL_LINE 4: NSFW error case. + } + } + } + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +BOOL CPersistence::HaveAllReleaseRequestsPersisted(std::string &f_ctagnotreleased) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + BOOL l_bRetVal = TRUE; + + TSourceRegistryListItr l_itTReg = m_mPersistRegistry.begin(); + + f_ctagnotreleased.assign(""); + + for (; l_itTReg != m_mPersistRegistry.end(); ++l_itTReg) { + TTagRegistryListItr l_itTRegList = (l_itTReg->second).begin(); + for (; l_itTRegList != (l_itTReg->second).end(); ++l_itTRegList) { + if (l_itTRegList->second.HasntBeenPersisted()) { + l_bRetVal = FALSE; + + if (!l_itTRegList->second.IsReleased()) { + f_ctagnotreleased.append("\n"); + f_ctagnotreleased.append(l_itTRegList->second.GetTag()); + f_ctagnotreleased.append(" ["); + f_ctagnotreleased.append(l_itTRegList->second.GetRequester()); + f_ctagnotreleased.append("]"); + } + } + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_bRetVal; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// PersistAllUserRequests +/// Persist all user files which are not persisted yet. +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistence::PersistAllUserRequests() { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + // TODO(my_username): Persist data on userchange. Uncomment following. + // m_bPersist = TRUE; // set to true because persist of all user release requests have been triggered. + // Trigger reason: user change + + TSourceRegistryListItr l_itTReg = m_mPersistRegistry.begin(); + + for (; l_itTReg != m_mPersistRegistry.end(); ++l_itTReg) { + TTagRegistryListItr l_itTRegList = (l_itTReg->second).begin(); + for (; l_itTRegList != (l_itTReg->second).end(); ++l_itTRegList) { + if (l_itTRegList->second.IsUserPersistence()) { + if (eFrameworkunifiedStatusOK != Persist(static_cast(l_itTRegList->second))) { // LCOV_EXCL_BR_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; // LCOV_EXCL_LINE 4: NSFW error case. + } + } + } + } + return l_estatus; +} + +BOOL CPersistence::IsUserPersistence(std::string f_ctag) { + BOOL l_bUserPersistence = FALSE; + + TSourceRegistryListItr l_itTReg = m_mPersistRegistry.begin(); + + for (; l_itTReg != m_mPersistRegistry.end(); ++l_itTReg) { + TTagRegistryListItr l_itTRegList = (l_itTReg->second).begin(); + for (; l_itTRegList != (l_itTReg->second).end(); ++l_itTRegList) { + if (l_itTRegList->second.GetTag() == f_ctag) { + if (l_itTRegList->second.IsUserPersistence()) { + l_bUserPersistence = TRUE; + } + break; + } + } + } + + return l_bUserPersistence; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// SetPersistentCategory +/// Sets the persist type of file/folder +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistence::SetPersistentCategory(const std::string &f_crequesterappname, + const std::string &f_ctag, + EFrameworkunifiedPersistCategory f_epersistcategory) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + // Persistence Registry map iterator + TSourceRegistryListItr l_itTSourceRegistryListItr = m_mPersistRegistry.find(f_crequesterappname); + + if (m_mPersistRegistry.end() != l_itTSourceRegistryListItr) { + // source available, check for file if registered + TTagRegistryListItr l_itTRegistryList = (l_itTSourceRegistryListItr->second).find(f_ctag); + + if ((l_itTSourceRegistryListItr->second).end() != l_itTRegistryList) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "AppName:: %s, Tag:: %s found in registry", f_crequesterappname.c_str(), + f_ctag.c_str()); + + l_estatus = (l_itTRegistryList->second).SetPersistentCategory(f_epersistcategory); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Warning: %s didn't register %s", f_crequesterappname.c_str(), f_ctag.c_str()); + l_estatus = eFrameworkunifiedStatusInvldParam; + } + } else { + // source not registered, cannot persist + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Warning: %s is not registered", f_ctag.c_str()); + l_estatus = eFrameworkunifiedStatusInvldParam; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// ResetPersistFlag +/// Resets the persist flag. +//////////////////////////////////////////////////////////////////////////////////////////// +VOID CPersistence::ResetPersistFlag() { + m_bPersist = FALSE; + + m_uiNotificationpersistentservicePersistCategoryFlag = 0; +} + +#ifdef NPP_PROFILEINFO_ENABLE + +EFrameworkunifiedStatus CPersistence::GetPersistenceProfilingData(std::string &f_cpersistenceprofileinfo) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + TSourceRegistryListItr l_itrTSourceRegistryListItr; + TTagRegistryListItr l_itrTTagRegistryListItr; + + for (l_itrTSourceRegistryListItr = m_mPersistRegistry.begin(); + l_itrTSourceRegistryListItr != m_mPersistRegistry.end(); + l_itrTSourceRegistryListItr++) { + for (l_itrTTagRegistryListItr = (l_itrTSourceRegistryListItr->second).begin(); + l_itrTTagRegistryListItr != (l_itrTSourceRegistryListItr->second).end(); + l_itrTTagRegistryListItr++) { + f_cpersistenceprofileinfo.append("\n"); + f_cpersistenceprofileinfo.append((*l_itrTSourceRegistryListItr).first); + f_cpersistenceprofileinfo.append(","); + + f_cpersistenceprofileinfo.append(l_itrTTagRegistryListItr->first); + f_cpersistenceprofileinfo.append(","); + + switch ((l_itrTTagRegistryListItr->second).GetPersistType()) { + case ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE: { + f_cpersistenceprofileinfo.append("File,"); + } + break; + + case ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER: { + f_cpersistenceprofileinfo.append("Folder,"); + } + break; + + default: { + f_cpersistenceprofileinfo.append(","); + } + break; + } + + if ((l_itrTTagRegistryListItr->second).IsUserPersistence()) { + f_cpersistenceprofileinfo.append("Yes,"); + } else { + f_cpersistenceprofileinfo.append("No,"); + } + + if ((l_itrTTagRegistryListItr->second).IsReleased()) { + f_cpersistenceprofileinfo.append("Yes,"); + } else { + f_cpersistenceprofileinfo.append("No,"); + } + + if ((l_itrTTagRegistryListItr->second).IsPersisted()) { + f_cpersistenceprofileinfo.append("Yes"); + } else { + f_cpersistenceprofileinfo.append("No"); + } + } + } + return l_estatus; +} + +#endif diff --git a/service/native/notification_persistent_service/server/src/ns_npp_persistence_manager.cpp b/service/native/notification_persistent_service/server/src/ns_npp_persistence_manager.cpp new file mode 100755 index 0000000..7f5d292 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_persistence_manager.cpp @@ -0,0 +1,1132 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NPPService +/// \brief This file contains implementation of class CPersistenceManager. +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "ns_npp.h" +#include "ns_npp_types.h" +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_copy_worker.h" +#include "ns_npp_persistence.h" +#include "ns_npp_persist_file.h" +#include "ns_npp_fs_directory.h" +#include "ns_npp_persist_folder.h" +#include "ns_npp_persistent_data.h" +#include "ns_npp_binary_accesser.h" +#include "ns_npp_persistence_manager.h" +#include "ns_npp_nor_persistence_worker_thread.h" +#include "ns_npp_state_nor_persistence_notification.h" + +extern const CHAR AppName[]; // NOLINT (readability/naming) + +// Initialisation of static class member for disabling persistence +BOOL CPersistenceManager::m_bPersistenceDisabled = FALSE; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CPersistenceManager +/// Constructor of CPersistenceManager class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CPersistenceManager::CPersistenceManager() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_cUserNotificationTag = USERNOTIFICATIONFILE; + + m_poDataAccesser = NULL; + + m_cNotificationPersistFilepath = CPersistence::GetStoragePath(); // LCOV_EXCL_BR_LINE 11: unexpected branch + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Storage path for persistence=%s", m_cNotificationPersistFilepath.c_str()); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + + m_cNotificationPersistFilepath += AppName; + m_cNotificationPersistFilepath += "/"; + + m_hNSImmediatePersistenceThread = NULL; + m_bAllFilePersisted = FALSE; + m_bImmediatedDataPersisted = FALSE; + + if (eFrameworkunifiedStatusOK != Init()) { // LCOV_EXCL_BR_LINE 6: Init() must be return eFrameworkunifiedStatusOK + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to initialize Persistent Manager."); // LCOV_EXCL_LINE 6: Init() must be return eFrameworkunifiedStatusOK // NOLINT[whitespace/line_length] + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CPersistenceManager +/// Destructor of CPersistenceManager class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CPersistenceManager::~CPersistenceManager() { // LCOV_EXCL_START 14: Resident process, global instance not released + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != m_poDataAccesser) { + delete m_poDataAccesser; + } + + Persist_Type_Iter l_itPersist_Type = m_mPersist_Type.begin(); + // Remove memory allocated for persistence objects + for (; l_itPersist_Type != m_mPersist_Type.end(); ++l_itPersist_Type) { + if (NULL != (*l_itPersist_Type).second) { + delete(*l_itPersist_Type).second; + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} +// LCOV_EXCL_STOP + +EFrameworkunifiedStatus CPersistenceManager::Init() { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_mPersist_Type[ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE] = new(std::nothrow) CFilePersistence(); // LCOV_EXCL_BR_LINE 11:unexpected branch + + m_mPersist_Type[ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER] = new(std::nothrow) CFolderPersistence(); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT[whitespace/line_length] + + m_poDataAccesser = new(std::nothrow) CBinaryAccesser(); // Save data in binary format. // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT[whitespace/line_length] + + // check if all object creation is successful + if (NULL != m_poDataAccesser) { // LCOV_EXCL_BR_LINE 5:m_poDataAccesser can`t be NULL + Persist_Type_Iter l_itPersist_Type = m_mPersist_Type.begin(); + + // check if all object creation is successful + for (; l_itPersist_Type != m_mPersist_Type.end(); + ++l_itPersist_Type) { + if (NULL == (*l_itPersist_Type).second) { // LCOV_EXCL_START 6:(*l_itPersist_Type).second can`t be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + break; + } + // LCOV_EXCL_STOP + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; // LCOV_EXCL_LINE 5: m_poDataAccesser can`t be NULL + } + + if (eFrameworkunifiedStatusOK != l_estatus) { // LCOV_EXCL_START 6: l_estatus must be eFrameworkunifiedStatusOK + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + if (NULL != m_poDataAccesser) { + delete m_poDataAccesser; + } + + Persist_Type_Iter l_itPersist_Type = m_mPersist_Type.begin(); + // check if all object creation is successful + for (; l_itPersist_Type != m_mPersist_Type.end(); ++l_itPersist_Type) { + if (NULL != (*l_itPersist_Type).second) { + delete(*l_itPersist_Type).second; + } + } + // LCOV_EXCL_STOP + } + std::string f_csourcepath = CPersistence::GetStoragePath(); + if (f_csourcepath.length() > 0) { // LCOV_EXCL_BR_LINE 6: f_csourcepath.length() is always bigger then 0 + f_csourcepath.append(RELEASETEMP_DIR); // LCOV_EXCL_BR_LINE 11:unexpected branch + if (CFSDirectory::DoesDirecotryExist(f_csourcepath)) { + f_csourcepath.append(RELEASETEMP_FILENAME); + if (0 != remove(f_csourcepath.c_str())) { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Temporary file not deleted::%s, errno:%d", f_csourcepath.c_str(), errno); + } + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceRegister +/// Registers a tag for the file/folder. This tag will be used for releasing or loading +/// a file/folder. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceRegister(std::string f_cappname, + std::string f_ctag, + ENotificationpersistentservicePersistType f_epersisttype, + BOOL bisuserpersistence) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + + if (f_cappname.empty() || f_ctag.empty()) { // LCOV_EXCL_BR_LINE 6: double check, f_cappname and f_ctag can't be empty // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Appname & tag should not be empty."); // LCOV_EXCL_LINE 6: f_cappname and f_ctag can't be empty // NOLINT[whitespace/line_length] + } else { + // check boundary conditions + if ((ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST < f_epersisttype) && (f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST)) { // LCOV_EXCL_BR_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST // NOLINT[whitespace/line_length] + if (NULL != m_mPersist_Type[f_epersisttype]) { // LCOV_EXCL_BR_LINE 6: m_mPersist_Type[f_epersisttype] would not be null // NOLINT[whitespace/line_length] + // register tag + l_estatus = m_mPersist_Type[f_epersisttype]->Register(f_cappname, f_ctag, + bisuserpersistence); // f_eRegisterType, f_cUser); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + // m_mPersist_Type[f_ePersistFileType]->ListAllInMap(); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", f_epersisttype); // LCOV_EXCL_LINE 6: m_mPersist_Type[f_epersisttype] would not be null // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Enum value %d is out of bound.", f_epersisttype); // LCOV_EXCL_LINE 6: f_epersisttype is always biger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST // NOLINT[whitespace/line_length] + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceRelease +/// Entry for the file/folder is stored in map for persistence. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceRelease(std::string f_cappname, + std::string f_ctag, + std::string f_cmempath, + EFrameworkunifiedReleaseType enotificationpersistentservicereleasetype, + ENotificationpersistentservicePersistType f_epersisttype, + std::string f_cusername) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + + if (f_cappname.empty() || f_ctag.empty() || f_cmempath.empty()) { // LCOV_EXCL_BR_LINE 6: double check, f_cappname, f_cmempath and f_ctag can't be empty // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Appname & tag should not be empty."); // LCOV_EXCL_LINE 6: double check, f_cappname, f_cmempath and f_ctag can't be empty // NOLINT[whitespace/line_length] + } else { + // check boundary conditions + if ((ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST < f_epersisttype) && (f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST)) { // LCOV_EXCL_BR_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST // NOLINT[whitespace/line_length] + // release file + if (NULL != m_mPersist_Type[f_epersisttype]) { // LCOV_EXCL_BR_LINE 6: m_mPersist_Type[f_epersisttype] would not be null // NOLINT[whitespace/line_length] + l_estatus = m_mPersist_Type[f_epersisttype]->Release(f_cappname, + f_ctag, + f_cmempath, + enotificationpersistentservicereleasetype, + f_cusername); // LCOV_EXCL_BR_LINE 11: unexpected branch + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", f_epersisttype); // LCOV_EXCL_LINE 6: m_mPersist_Type[f_epersisttype] would not be null // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Enum value %d is out of bound.", f_epersisttype); // LCOV_EXCL_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST // NOLINT[whitespace/line_length] + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceLoad +/// Load file/folder from persistent memory to the specified location. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceLoad(std::string f_cappname, + std::string f_ctag, + std::string f_cretrievepath, + ENotificationpersistentservicePersistType f_epersisttype, + std::string f_cusername) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (f_cappname.empty() || f_ctag.empty() || f_cretrievepath.empty()) { // LCOV_EXCL_BR_LINE 6: double check, f_cretrievepath, f_cappname and f_ctag can't be empty // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Appname, tag & retrieve path should not be empty."); // LCOV_EXCL_LINE 6: double check, f_cretrievepath, f_cappname and f_ctag can't be empty // NOLINT[whitespace/line_length] + } else { + // check boundary conditions + if ((ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST < f_epersisttype) && (f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST)) { // LCOV_EXCL_BR_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST // NOLINT[whitespace/line_length] + if (NULL != m_mPersist_Type[f_epersisttype]) { // LCOV_EXCL_BR_LINE 6: m_mPersist_Type[f_epersisttype] would not be null // NOLINT[whitespace/line_length] + // load file + l_estatus = m_mPersist_Type[f_epersisttype]->Load(f_cappname, f_ctag, f_cretrievepath, f_cusername); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", f_epersisttype); // LCOV_EXCL_LINE 6: m_mPersist_Type[f_epersisttype] would not be null // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Enum value %d is out of bound.", f_epersisttype); // LCOV_EXCL_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST // NOLINT[whitespace/line_length] + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// AckReceivedFromWorker +/// Send release ack to file/folder persistence object. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::AckReceivedFromWorker(PCSTR f_csource, PCSTR f_ctag, ENotificationpersistentservicePersistType f_epersisttype, + BOOL f_bcopystatus, ENPS_Loadtype f_eloadtype) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if ((NULL == f_csource) || (NULL == f_ctag)) { // LCOV_EXCL_BR_LINE 6: f_csource and f_ctag can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "f_csource or f_ctag is NULL."); // LCOV_EXCL_LINE 6: f_csource and f_ctag can't be NULL // NOLINT[whitespace/line_length] + } else { + // check boundary conditions + if ((ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST < f_epersisttype) && (f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST)) { // LCOV_EXCL_BR_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST // NOLINT[whitespace/line_length] + if (NULL != m_mPersist_Type[f_epersisttype]) { + // Send release ack to file/folder persistence object. + l_estatus = m_mPersist_Type[f_epersisttype]->AckReceivedFromWorker(f_csource, f_ctag, + f_bcopystatus, f_eloadtype); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", f_epersisttype); + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Enum value %d is out of bound.", f_epersisttype); // LCOV_EXCL_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST // NOLINT[whitespace/line_length] + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceSaveNotificationData +/// Save notification data in a persistent file. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceSaveNotificationData(Persistent_Notification_List_Type + *f_vpersistentnotificationlist) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if ((NULL == m_poDataAccesser) || (NULL == f_vpersistentnotificationlist)) { // LCOV_EXCL_BR_LINE 6: m_poDataAccesser and f_vpersistentnotificationlist would not be null // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "m_poDataAccesser or f_vpersistentnotificationlist is NULL."); // LCOV_EXCL_LINE 6: m_poDataAccesser and f_vpersistentnotificationlist would not be null // NOLINT[whitespace/line_length] + } else { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + std::string l_cNotificationFilePath = ""; + + l_cNotificationFilePath = m_cNotificationPersistFilepath; + l_cNotificationFilePath += NOTIFICATIONFILE; + if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->PersistData(l_cNotificationFilePath, + f_vpersistentnotificationlist, + eFrameworkunifiedPersistedStateVar, + eFrameworkunifiedUserData))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d", + l_cNotificationFilePath.c_str(), l_estatus); + } + + l_cNotificationFilePath = m_cNotificationPersistFilepath; + l_cNotificationFilePath += FACTORYNOTIFICATIONFILE; + if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->PersistData(l_cNotificationFilePath, + f_vpersistentnotificationlist, + eFrameworkunifiedPersistedStateVar, + eFrameworkunifiedFactoryData))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d", + l_cNotificationFilePath.c_str(), l_estatus); + } + + l_cNotificationFilePath = m_cNotificationPersistFilepath; + l_cNotificationFilePath += FACTORYCUSTOMERNOTIFICATIONFILE; + if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->PersistData(l_cNotificationFilePath, + f_vpersistentnotificationlist, + eFrameworkunifiedPersistedStateVar, + eFrameworkunifiedFactoryCustomerData))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d", + l_cNotificationFilePath.c_str(), l_estatus); + } + + l_cNotificationFilePath = m_cNotificationPersistFilepath; + l_cNotificationFilePath += DEALERNOTIFICATIONFILE; + if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->PersistData(l_cNotificationFilePath, + f_vpersistentnotificationlist, + eFrameworkunifiedPersistedStateVar, + eFrameworkunifiedDealerData))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d", + l_cNotificationFilePath.c_str(), l_estatus); + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eFrameworkunifiedStatusOK; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceSaveUserNotificationData +/// Save user notification data in a persistent file. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceSaveUserNotificationData(Persistent_Notification_List_Type + *f_vpersistentnotificationlist) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if ((NULL == m_poDataAccesser) || (NULL == f_vpersistentnotificationlist)) { // LCOV_EXCL_BR_LINE 6: m_poDataAccesser and f_vpersistentnotificationlist would not be null // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "m_poDataAccesser or f_vpersistentnotificationlist is NULL."); // LCOV_EXCL_LINE 6: m_poDataAccesser and f_vpersistentnotificationlist would not be null // NOLINT[whitespace/line_length] + } else { + l_estatus = m_poDataAccesser->PersistData(m_cNotificationUserMemFilepath, + f_vpersistentnotificationlist, + eFrameworkunifiedPersistedStateUserVar); // LCOV_EXCL_BR_LINE 11: unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceReadNotificationData +/// Get the list of all persistent notifications from a persistent memory and store it in a map. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceReadNotificationData(Persistent_Notification_List_Type + * &f_vpersistentnotificationlist) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != m_poDataAccesser) { // LCOV_EXCL_BR_LINE 6: m_poDataAccesser would not be null + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + std::string l_cNotificationFilePath = ""; + + l_cNotificationFilePath = m_cNotificationPersistFilepath; + l_cNotificationFilePath += NOTIFICATIONFILE; + if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->RetrieveData(l_cNotificationFilePath, + f_vpersistentnotificationlist, + eFrameworkunifiedUserData))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d", + l_cNotificationFilePath.c_str(), l_estatus); + } + + l_cNotificationFilePath = m_cNotificationPersistFilepath; + l_cNotificationFilePath += FACTORYNOTIFICATIONFILE; + if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->RetrieveData(l_cNotificationFilePath, + f_vpersistentnotificationlist, + eFrameworkunifiedFactoryData))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d", + l_cNotificationFilePath.c_str(), l_estatus); + } + + l_cNotificationFilePath = m_cNotificationPersistFilepath; + l_cNotificationFilePath += FACTORYCUSTOMERNOTIFICATIONFILE; + if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->RetrieveData(l_cNotificationFilePath, + f_vpersistentnotificationlist, + eFrameworkunifiedFactoryCustomerData))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d", + l_cNotificationFilePath.c_str(), l_estatus); + } + + l_cNotificationFilePath = m_cNotificationPersistFilepath; + l_cNotificationFilePath += DEALERNOTIFICATIONFILE; + if (eFrameworkunifiedStatusOK != (l_estatus = m_poDataAccesser->RetrieveData(l_cNotificationFilePath, + f_vpersistentnotificationlist, + eFrameworkunifiedDealerData))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error retrieving notification data from file : %s, status: %d", + l_cNotificationFilePath.c_str(), l_estatus); + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eFrameworkunifiedStatusOK; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceReadUserNotificationData +/// Get the list of all user persistent notifications from a persistent memory and store it in a map. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceReadUserNotificationData(Persistent_Notification_List_Type + * &f_vpersistentnotificationlist) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != m_poDataAccesser) { // LCOV_EXCL_BR_LINE 6: m_poDataAccesser would not be null + l_estatus = m_poDataAccesser->RetrieveData(m_cNotificationUserMemFilepath, + f_vpersistentnotificationlist, + eFrameworkunifiedUserData); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// PersistAllReleaseRequests +/// Persist all released files and folder contained in the map in persistent memory. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::PersistAllReleaseRequests(UI_32 f_uinotificationpersistentservicepersistcategoryflag) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + ENotificationpersistentservicePersistType l_ePersistType = ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST; + l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1); + + // Persist all i.e files and folders + while (l_ePersistType < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST) { + if (NULL != m_mPersist_Type[l_ePersistType]) { + if (eFrameworkunifiedStatusFail == m_mPersist_Type[l_ePersistType]->PersistAllReleaseRequests(f_uinotificationpersistentservicepersistcategoryflag)) { // LCOV_EXCL_BR_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; // LCOV_EXCL_LINE 4: NSFW error case. + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", l_ePersistType); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + + l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentservicePersistAllUserRequests +/// Persist all user files and folder contained in the map in persistent memory. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentservicePersistAllUserRequests() { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + ENotificationpersistentservicePersistType l_ePersistType = ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST; + l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1); + + // Persist all i.e files and folders + while (l_ePersistType < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST) { + if (NULL != m_mPersist_Type[l_ePersistType]) { + l_estatus = m_mPersist_Type[l_ePersistType]->PersistAllUserRequests(); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", l_ePersistType); + } + + l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + + + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// SetReadThreadHandle +/// Pass the handle of the read thread to the object of file/folder persistence +//////////////////////////////////////////////////////////////////////////////////////////////// +VOID CPersistenceManager::SetReadThreadHandle(HANDLE f_hreadthread) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (f_hreadthread != NULL) { // LCOV_EXCL_BR_LINE 6: f_hreadthread would not be null + // Set thread handle for object persistfile objects. i.e. for file/folder + for (Persist_Type_Iter l_itPersist_Type = m_mPersist_Type.begin(); + l_itPersist_Type != m_mPersist_Type.end(); + ++l_itPersist_Type) { + if (NULL != (*l_itPersist_Type).second) { // LCOV_EXCL_BR_LINE 6: (*l_itPersist_Type).second can't be NULL + (*l_itPersist_Type).second->SetReadThreadHandle(f_hreadthread); + } + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// SetWriteThreadHandle +/// Pass the handle of the write thread to the object of file/folder persistence +//////////////////////////////////////////////////////////////////////////////////////////////// +VOID CPersistenceManager::SetWriteThreadHandle(HANDLE f_hwritethread) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != f_hwritethread) { // LCOV_EXCL_BR_LINE 6: f_hwritethread would not be null + // Set thread handle for object persist objects. i.e. for file/folder + for (Persist_Type_Iter l_itPersist_Type = m_mPersist_Type.begin(); + l_itPersist_Type != m_mPersist_Type.end(); + ++l_itPersist_Type) { + if (NULL != (*l_itPersist_Type).second) { // LCOV_EXCL_BR_LINE 6: (*l_itPersist_Type).second can't be NULL + (*l_itPersist_Type).second->SetWriteThreadHandle(f_hwritethread); + } + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// SetWriteThreadHandle +/// Pass the handle of the write thread to the object of file/folder persistence +//////////////////////////////////////////////////////////////////////////////////////////////// +VOID CPersistenceManager::SetNorPersistenceThreadHandle(HANDLE f_hwritethread) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != f_hwritethread) { // LCOV_EXCL_BR_LINE 6: f_hwritethread would not be null + m_hNSImmediatePersistenceThread = f_hwritethread; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPServiceOnCpWorkerAckCmd +/// Handles when the CopyWorker sends an ack back for a message received . +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPServiceOnCpWorkerAckCmd(HANDLE f_happ) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + NSP_CopyAckMsg l_tack = {}; + if (f_happ) { // LCOV_EXCL_BR_LINE 4: NSFW error case. + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(f_happ, (PVOID)&l_tack, sizeof(NSP_CopyAckMsg), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] // NOLINT[whitespace/line_length] + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "CP_WRK_ACK_CMD_COMPLETE for cmd 0x%X", l_tack.m_eworkerprotocol); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } else { + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Unable to get message data in NPServiceOnCpWorkerAckCmd, status : 0x%x", l_estatus); + // LCOV_EXCL_STOP + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; // LCOV_EXCL_LINE 4: NSFW error case. + } + + return l_estatus; +} + + +//////////////////////////////////////////////////////////////////////////////////////////// +/// SetUserPersistentPath +/// +//////////////////////////////////////////////////////////////////////////////////////////// +VOID CPersistenceManager::SetUserPersistentPath(std::string f_cusername) { + m_cNotificationUserMemFilepath = CPersistence::GetStoragePath(); + m_cNotificationUserMemFilepath += AppName; + m_cNotificationUserMemFilepath += "/"; + m_cNotificationUserMemFilepath += f_cusername; + m_cNotificationUserMemFilepath += "/"; + m_cNotificationUserMemFilepath += m_cUserNotificationTag; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// IsUserPersistence +/// Check if tag is user persistence +//////////////////////////////////////////////////////////////////////////////////////////// +BOOL CPersistenceManager::IsUserPersistence(std::string f_ctag, ENotificationpersistentservicePersistType f_epersisttype) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + BOOL l_bUserPersistence = FALSE; + + // check boundary conditions + if ((ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST < f_epersisttype) && (f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST)) { // LCOV_EXCL_BR_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST // NOLINT[whitespace/line_length] + if (NULL != m_mPersist_Type[f_epersisttype]) { // LCOV_EXCL_BR_LINE 6: m_mPersist_Type[f_epersisttype] can't be null // NOLINT[whitespace/line_length] + // load file + l_bUserPersistence = m_mPersist_Type[f_epersisttype]->IsUserPersistence(f_ctag); // LCOV_EXCL_BR_LINE 11:unexpected branch // NOLINT[whitespace/line_length] + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", f_epersisttype); // LCOV_EXCL_LINE 6: m_mPersist_Type[f_epersisttype] can't be null // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Enum value %d is out of bound.", f_epersisttype); // LCOV_EXCL_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST // NOLINT[whitespace/line_length] + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_bUserPersistence; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// HaveAllReleaseRequestsPersisted +/// Check if all release requests processed or not +//////////////////////////////////////////////////////////////////////////////////////////// +BOOL CPersistenceManager::HaveAllReleaseRequestsPersisted() { + BOOL l_bRetVal = TRUE; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // check if all files are persisted + if (FALSE == m_bAllFilePersisted) { + ENotificationpersistentservicePersistType l_ePersistType = ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST; + l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1); + + std::string l_cTagNotReleased = ""; + std::string l_cTagList = ""; // LCOV_EXCL_BR_LINE 11:except,C++ STL + + // Persist all i.e files and folders + while (l_ePersistType < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST) { + if (NULL != m_mPersist_Type[l_ePersistType]) { + l_cTagNotReleased.assign(""); // LCOV_EXCL_BR_LINE 11:except,C++ STL + // if(eFrameworkunifiedStatusFail == m_mPersist_Type[l_ePersistType]->PersistAllReleaseRequests()) + if (FALSE == m_mPersist_Type[l_ePersistType]->HaveAllReleaseRequestsPersisted(l_cTagNotReleased)) { + l_bRetVal = FALSE; + l_cTagList.append(l_cTagNotReleased); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", l_ePersistType); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + + l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1); + } + + if (0 != l_cTagList.size()) { + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Tags not released:: %s", l_cTagList.c_str()); + } + } + + if (TRUE == l_bRetVal) { + m_bAllFilePersisted = TRUE; + + // if all files are persisted set the return value to the status of immediate data persistency + l_bRetVal = m_bImmediatedDataPersisted; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_bRetVal; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// ResetPersistFlag +/// +//////////////////////////////////////////////////////////////////////////////////////////// +VOID CPersistenceManager::ResetPersistFlag() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + ENotificationpersistentservicePersistType l_ePersistType = ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST; + l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1); + + // Persist all i.e files and folders + while (l_ePersistType < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST) { + if (NULL != m_mPersist_Type[l_ePersistType]) { + m_mPersist_Type[l_ePersistType]->ResetPersistFlag(); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", l_ePersistType); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + + l_ePersistType = (ENotificationpersistentservicePersistType)(l_ePersistType + 1); + } + + m_bAllFilePersisted = FALSE; + + m_bImmediatedDataPersisted = FALSE; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceReadNorNotificationData +/// Get the list of all user persistent notifications from a persistent memory and store it in a map. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceReadNorNotificationData(Persistent_Notification_List_Type + * &f_vpersistentnotificationlist) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (eFrameworkunifiedStatusOK != ReadImmediateNotificationData(f_vpersistentnotificationlist, eFrameworkunifiedUserData)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "No Immediate User data in persistent memory"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + + if (eFrameworkunifiedStatusOK != ReadImmediateNotificationData(f_vpersistentnotificationlist, eFrameworkunifiedFactoryData)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "No Immediate Factory data in persistent memory"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + + if (eFrameworkunifiedStatusOK != ReadImmediateNotificationData(f_vpersistentnotificationlist, eFrameworkunifiedFactoryCustomerData)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "No Immediate Factory Customer data in persistent memory"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + + if (eFrameworkunifiedStatusOK != ReadImmediateNotificationData(f_vpersistentnotificationlist, eFrameworkunifiedDealerData)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "No Immediate Dealer data in persistent memory"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// ClearPersistenceData +/// Deletes the data from the persistent memory. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::ClearPersistenceData(const EFrameworkunifiedClearPersistence &f_enotificationpersistentserviceclearpersistencescope) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + // persistence memory path to be cleared + std::string l_cPath = ""; + + switch (f_enotificationpersistentserviceclearpersistencescope) { // LCOV_EXCL_BR_LINE 6: f_enotificationpersistentserviceclearpersistencescope must be eFrameworkunifiedClearAllData, eFrameworkunifiedClearAllApplicationData, eFrameworkunifiedClearAllNotificationData, eFrameworkunifiedClearCurrentUserData, eFrameworkunifiedClearCurrentUserApplicationData, eFrameworkunifiedClearCurrentUserNotificationData. // NOLINT[whitespace/line_length] + case eFrameworkunifiedClearAllData: { + // clears all the data from the persistent memory + l_cPath.append(CPersistence::GetStoragePath()); + } + break; + + case eFrameworkunifiedClearAllApplicationData: { + // TODO(my_username): clears all the application folder in persistence memory + // don't delete the NS_NPS folder + } + break; + + case eFrameworkunifiedClearAllNotificationData: { + // TODO(my_username): deletes the NS_NPS folder + } + break; + + case eFrameworkunifiedClearCurrentUserData: { + // TODO(my_username): deletes the user folder from all the application folder in persisted memory + // as well as from the NS_NPS folder + } + break; + + case eFrameworkunifiedClearCurrentUserApplicationData: { + // TODO(my_username): deletes the user folder from all the application folder + } + break; + + case eFrameworkunifiedClearCurrentUserNotificationData: { + // TODO(my_username): deletes the user folder from the NS_NPS folder + } + break; + + default: { + // LCOV_EXCL_START 6: f_enotificationpersistentserviceclearpersistencescope must be eFrameworkunifiedClearAllData, eFrameworkunifiedClearAllApplicationData, eFrameworkunifiedClearAllNotificationData, eFrameworkunifiedClearCurrentUserData, eFrameworkunifiedClearCurrentUserApplicationData, eFrameworkunifiedClearCurrentUserNotificationData. // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Invalid _EFrameworkunifiedClearPersistence Parameter:: %d", f_enotificationpersistentserviceclearpersistencescope); + l_estatus = eFrameworkunifiedStatusInvldParam; + // LCOV_EXCL_STOP + } + break; + } + + if (0 != l_cPath.size()) { + if (CFSDirectory::DoesDirecotryExist(l_cPath)) { + if (TRUE == CFSDirectory::RemoveDirectory(l_cPath)) { // LCOV_EXCL_BR_LINE 6: RemoveDirectory always return ok + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Delete persistent directory successful : %s", l_cPath.c_str()); + } else { + // LCOV_EXCL_START 6: RemoveDirectory always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Delete persistent directory unsuccessful : %s", l_cPath.c_str()); + l_estatus = eFrameworkunifiedStatusErrOther; + // LCOV_EXCL_STOP + } + } + } else { + l_estatus = eFrameworkunifiedStatusErrOther; + } + + // delete NOR data + l_cPath.clear(); + l_cPath.append(IMMEDIATE_PERSISTENCE_STORAGE_V2); + if (0 != l_cPath.size()) { // LCOV_EXCL_BR_LINE 6: l_cPath.size can't be 0 + if (CFSDirectory::DoesDirecotryExist(l_cPath)) { + if (TRUE == CFSDirectory::RemoveDirectory(l_cPath)) { // LCOV_EXCL_BR_LINE 6: RemoveDirectory always return ok + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Delete nor persistent directory successful : %s", l_cPath.c_str()); + } else { + // LCOV_EXCL_START 6: RemoveDirectory always return ok + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Delete nor persistent directory unsuccessful : %s", l_cPath.c_str()); + l_estatus = eFrameworkunifiedStatusErrOther; + // LCOV_EXCL_STOP + } + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusErrOther; // LCOV_EXCL_LINE 6: l_cPath.size can't be 0 + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceSetPersistentCategory +/// Sets the persist type of file or folder. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::NotificationpersistentserviceSetPersistentCategory(std::string f_crequestorname, + std::string f_ctag, + EFrameworkunifiedPersistCategory f_epersistcategory, + ENotificationpersistentservicePersistType f_epersisttype) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + if (f_ctag.empty()) { // LCOV_EXCL_BR_LINE 6: double check, f_ctag.size can't be empty + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Tag name is empty."); // LCOV_EXCL_LINE 6: double check, f_ctag.size can't be empty + } else { + // check boundary conditions + if ((ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST < f_epersisttype) && (f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST)) { // LCOV_EXCL_BR_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST // NOLINT[whitespace/line_length] + if (NULL != m_mPersist_Type[f_epersisttype]) { // LCOV_EXCL_BR_LINE 6: m_mPersist_Type[f_epersisttype] can't be null // NOLINT[whitespace/line_length] + // set the persist type + l_estatus = m_mPersist_Type[f_epersisttype]->SetPersistentCategory(f_crequestorname, + f_ctag, + f_epersistcategory); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistence object for %d is null.", f_epersisttype); // LCOV_EXCL_LINE 6: m_mPersist_Type[f_epersisttype] can't be null // NOLINT[whitespace/line_length] + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Enum value %d is out of bound.", f_epersisttype); // LCOV_EXCL_LINE 6: f_epersisttype is always bigger then ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST and less then ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST // NOLINT[whitespace/line_length] + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// PersistNORData +/// Sends the message to Immediate Persistence Thread to Persists the data immediately or reset +/// the NOR data depending on persist category flag during shutdown irrespective of delay. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::PersistNORData(EFrameworkunifiedShutdownType f_eshutdowntype, UI_32 f_uinotificationpersistentservicepersistcategoryflag) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + TImmediateShutdown l_tImmShutdown = {}; + l_tImmShutdown.f_eshutdowntype = f_eshutdowntype; + l_tImmShutdown.f_uinotificationpersistentservicepersistcategoryflag = f_uinotificationpersistentservicepersistcategoryflag; + + // send the message to NOR to persist or reset the data during shutdown + if (NULL != CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread) { // LCOV_EXCL_BR_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK != (l_estatus = McSend(CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread, AppName, NOR_PERSISTENCE_ONSHUTDOWN, sizeof(l_tImmShutdown), &l_tImmShutdown))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "McSend for cmd 0x%X failed", NOR_PERSISTENCE_ONSHUTDOWN); // LCOV_EXCL_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// SetImmediateDataPersistedStatus +/// Set/Reset the persistence status of immediate persistence data +/////////////////////////////////////////////////////////////////////////////////////////// +VOID CPersistenceManager::SetImmediateDataPersistedStatus(BOOL f_bstatus) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_bImmediatedDataPersisted = f_bstatus; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// SetFilePersistedStatus +/// Set/Reset the persistence status of files and folders +/////////////////////////////////////////////////////////////////////////////////////////// +VOID CPersistenceManager::SetFilePersistedStatus(BOOL f_bstatus) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_bAllFilePersisted = f_bstatus; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// ReadImmediateNotificationData +/// Get the list of all immediate persistent notifications of f_epersistcategory from a +/// persistent memory and store it in a map. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CPersistenceManager::ReadImmediateNotificationData(Persistent_Notification_List_Type + * &f_vpersistentnotificationlist, + const EFrameworkunifiedPersistCategory f_epersistcategory) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + std::string l_pcPath = IMMEDIATE_PERSISTENCE_STORAGE_V2; + std::string l_cNotificationName = ""; // LCOV_EXCL_BR_LINE 11:except,C++ STL + // stores the list of invalid immediate notification files at persistent location + std::string l_cInvalidFileList = ""; // LCOV_EXCL_BR_LINE 11:except,C++ STL + + PCSTR l_pPublisherName = NULL; + PSTR l_pData = NULL; + UI_32 l_uiDataSize = 0; + + NC_NorPersistentData l_ptNorPersistentData = {}; + + TFileList l_pTFileList; + + if ('/' != l_pcPath[l_pcPath.length() - 1]) { // LCOV_EXCL_BR_LINE 6: the last char is always '/' + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_pcPath.append("/"); // LCOV_EXCL_LINE 6: the last char is always '/' + } + + switch (f_epersistcategory) { + case eFrameworkunifiedFactoryData: { + l_pcPath.append(FACTORYDATADIR); // LCOV_EXCL_BR_LINE 11:except,C++ STL + } + break; + + case eFrameworkunifiedFactoryCustomerData: { + l_pcPath.append(FACTORYCUSTOMERDATADIR); // LCOV_EXCL_BR_LINE 11:except,C++ STL + } + break; + + case eFrameworkunifiedDealerData: { + l_pcPath.append(DEALERDATADIR); // LCOV_EXCL_BR_LINE 11:except,C++ STL + } + break; + + case eFrameworkunifiedUserData: + default: { + l_pcPath.append(USERDATADIR); // LCOV_EXCL_BR_LINE 11:except,C++ STL + l_pcPath.append(ALLUSERAPPDATADIR); // LCOV_EXCL_BR_LINE 11:except,C++ STL + } + break; + } + + l_pcPath.append(IMMEDIATEDATADIR); // LCOV_EXCL_BR_LINE 11:except,C++ STL + + if (eFrameworkunifiedStatusOK == GetFileList(&l_pTFileList, l_pcPath.c_str())) { // LCOV_EXCL_BR_LINE 4: NSFW error case. + if (!l_pTFileList.empty()) { // LCOV_EXCL_BR_LINE 200: if GetFileList() returns eFrameworkunifiedStatusOK, l_pTFileList can't be empty // NOLINT[whitespace/line_length] + for (UI_32 l_uiCount = 0; l_uiCount < l_pTFileList.size(); l_uiCount++) { + l_uiDataSize = 0; + + // get the persistent notification name from vector + l_cNotificationName = l_pTFileList.at(l_uiCount); + + if (eFrameworkunifiedStatusOK == NPSynchronousGetPersistentDataSize(l_cNotificationName.c_str(), &l_uiDataSize, // LCOV_EXCL_BR_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + f_epersistcategory) && (0 != l_uiDataSize)) { + l_pData = new(std::nothrow) CHAR[l_uiDataSize]; + std::memset(l_pData, 0, l_uiDataSize); + + if (NULL != l_pData) { // LCOV_EXCL_BR_LINE 6: l_pData can't be null + l_pPublisherName = NULL; + + // clear the memory + std::memset(&l_ptNorPersistentData, 0, sizeof(NC_NorPersistentData)); + + // As NS_NPP does a recursive filename read from directory it has the complete filename. + // So it does not require to pass the Publisher name i.e. l_pPublisherName.So it is being passed as NULL. + if (eFrameworkunifiedStatusOK == NPSynchronousGetPersistentData(l_pPublisherName, // LCOV_EXCL_BR_LINE 4: NSFW error case. // NOLINT[whitespace/line_length] + l_cNotificationName.c_str(), + (PVOID)l_pData, + l_uiDataSize, + l_ptNorPersistentData, + f_epersistcategory)) { + CNotificationsToPersist *l_objCNotificationsToPersist = new(std::nothrow) CNotificationsToPersist(); + if (NULL != l_objCNotificationsToPersist) { // LCOV_EXCL_BR_LINE 6: l_objCNotificationsToPersist can't be null // NOLINT[whitespace/line_length] + CPersistentData *l_objCPersistentData = new(std::nothrow) CPersistentData(); + + // fill the appropriate values in l_objCNotificationsToPersist + if (NULL != l_objCPersistentData) { // LCOV_EXCL_BR_LINE 6: l_objCPersistentData can't be null + l_objCPersistentData->m_pMessage = new(std::nothrow) CHAR[l_ptNorPersistentData.dataSize]; + std::memset(l_objCPersistentData->m_pMessage, 0, l_ptNorPersistentData.dataSize); + + if (NULL != l_objCPersistentData->m_pMessage) { // LCOV_EXCL_BR_LINE 6: l_objCPersistentData->m_pMessage can't be null // NOLINT[whitespace/line_length] + std::memcpy(l_objCPersistentData->m_pMessage, l_pData, l_ptNorPersistentData.dataSize); + + l_objCNotificationsToPersist->m_uiMaxMsgLength = l_ptNorPersistentData.uiMaxSize; + l_objCPersistentData->m_uiMsgSize = l_ptNorPersistentData.dataSize; + l_objCNotificationsToPersist->m_ePersistentType = eFrameworkunifiedImmediatePersistedStateVar; + + l_objCNotificationsToPersist->m_cNotificationName = l_ptNorPersistentData.notificationName; + l_objCNotificationsToPersist->m_cPublisherName = l_ptNorPersistentData.pPublisherName; + l_objCNotificationsToPersist->m_uiDelay = l_ptNorPersistentData.uiDelay; + + l_objCNotificationsToPersist->m_pPersistentData = l_objCPersistentData; + + l_objCNotificationsToPersist->m_ePersistCategory = f_epersistcategory; + + f_vpersistentnotificationlist->push_back(l_objCNotificationsToPersist); + } else { + // LCOV_EXCL_START 6: l_objCPersistentData->m_pMessage can't be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Memory allocation error for notification data of size %d", + l_ptNorPersistentData.dataSize); + + if (NULL != l_objCNotificationsToPersist) { + delete l_objCNotificationsToPersist; + l_objCNotificationsToPersist = NULL; + } + + if (NULL != l_objCPersistentData) { + delete l_objCPersistentData; + l_objCPersistentData = NULL; + } + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: l_objCPersistentData can't be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Memory allocation error for CPersistentData object"); + + if (NULL != l_objCNotificationsToPersist) { + delete l_objCNotificationsToPersist; + l_objCNotificationsToPersist = NULL; + } + // LCOV_EXCL_STOP + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Memory allocation error for CNotificationsToPersist object"); // LCOV_EXCL_LINE 6: l_objCNotificationsToPersist can't be null // NOLINT[whitespace/line_length] + } + } else { + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_cInvalidFileList.append(l_cNotificationName); + l_cInvalidFileList.append(","); + // LCOV_EXCL_STOP + } + + delete[] l_pData; + l_pData = NULL; + } else { + // LCOV_EXCL_START 6: l_pData can't be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Persistent data received as NULL from immediate notification file :: %s", + l_cNotificationName.c_str()); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 4: NSFW error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_cInvalidFileList.append(l_cNotificationName); + l_cInvalidFileList.append(","); + // LCOV_EXCL_STOP + } + } + + if (0 != l_cInvalidFileList.size()) { // LCOV_EXCL_START 200: l_cInvalidFileList's size must be 0 + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, + "Unable to get persistent data for following immediate notification files :: %s", + l_cInvalidFileList.c_str()); + } + // LCOV_EXCL_STOP + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "No Immediate persistence data available at :: %s", l_pcPath.c_str()); // LCOV_EXCL_LINE 200: if GetFileList() returns eFrameworkunifiedStatusOK, l_pTFileList can't be empty // NOLINT[whitespace/line_length] + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to get the list of files from Immediate persistent location :: %s", + l_pcPath.c_str()); + l_estatus = eFrameworkunifiedStatusFail; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +#ifdef NPP_PROFILEINFO_ENABLE + +EFrameworkunifiedStatus CPersistenceManager::GetPersistenceProfilingData(std::string &f_cpersistenceprofileinfo) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + f_cpersistenceprofileinfo.append("Application Name,"); + f_cpersistenceprofileinfo.append("Tag Name,"); + f_cpersistenceprofileinfo.append("Type,"); + f_cpersistenceprofileinfo.append("UserSpecific,"); + f_cpersistenceprofileinfo.append("Released,"); + f_cpersistenceprofileinfo.append("Persisted"); + + CPersistence *l_pPersistence = m_mPersist_Type[ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE]; + l_pPersistence->GetPersistenceProfilingData(f_cpersistenceprofileinfo); + + l_pPersistence = m_mPersist_Type[ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER]; + l_pPersistence->GetPersistenceProfilingData(f_cpersistenceprofileinfo); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +#endif diff --git a/service/native/notification_persistent_service/server/src/ns_npp_persistent_data.cpp b/service/native/notification_persistent_service/server/src/ns_npp_persistent_data.cpp new file mode 100755 index 0000000..8a9127e --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_persistent_data.cpp @@ -0,0 +1,58 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CPersistentData. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include "ns_npp_persistent_data.h" + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// CPersistentData +/// Constructor of CPersistentData class +//////////////////////////////////////////////////////////////////////////////////////////////// +CPersistentData::CPersistentData() { + m_pMessage = NULL; + m_uiMsgSize = 0; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CPersistentData +/// Destructor of CPersistentData class +//////////////////////////////////////////////////////////////////////////////////////////////// +CPersistentData::~CPersistentData() { + if (NULL != m_pMessage) { + delete[](static_cast(m_pMessage)); // LCOV_EXCL_BR_LINE 11: unexpected branch + m_pMessage = NULL; + } +} + + + + + + diff --git a/service/native/notification_persistent_service/server/src/ns_npp_personalization_manager.cpp b/service/native/notification_persistent_service/server/src/ns_npp_personalization_manager.cpp new file mode 100755 index 0000000..4371465 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_personalization_manager.cpp @@ -0,0 +1,181 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CnotificationpersistentservicePersonalizationManager. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include +#include +#ifdef AGL_STUB +#include "ns_npp_personalization_manager.h" +#else +#include "ns_npp_Personalization_manager.h" +#endif +#include "ns_npp_notificationpersistentservicelog.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CnotificationpersistentservicePersonalizationManager +/// Constructor of CnotificationpersistentservicePersonalizationManager class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CnotificationpersistentservicePersonalizationManager::CnotificationpersistentservicePersonalizationManager() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_uiUserId = 0; + + m_cCurrentPersonality.clear(); + + m_pmPersonality = new(std::nothrow) Personality_Type(); // LCOV_EXCL_BR_LINE 11: except,C++ STL + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CnotificationpersistentservicePersonalizationManager +/// Destructor of CnotificationpersistentservicePersonalizationManager class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CnotificationpersistentservicePersonalizationManager::~CnotificationpersistentservicePersonalizationManager() { // LCOV_EXCL_START 14: Resident process, global instance not released // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != m_pmPersonality) { + m_pmPersonality->clear(); + + delete m_pmPersonality; + m_pmPersonality = NULL; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceGetPersonality +/// This function is used to get the current personality. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CnotificationpersistentservicePersonalizationManager::NotificationpersistentserviceGetPersonality(std::string &f_cpersonalityname) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + f_cpersonalityname = m_cCurrentPersonality; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceSetPersonality +/// This function is used to set the new personality. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CnotificationpersistentservicePersonalizationManager::NotificationpersistentserviceSetPersonality(const std::string f_cpersonalityname) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // iterator to find personality name from map of personality + Personality_Type::iterator l_itPersonality; + + if (!f_cpersonalityname.empty()) { + if (NULL != m_pmPersonality) { // LCOV_EXCL_BR_LINE 6: double check, m_pmPersonality can't be NULL + l_itPersonality = m_pmPersonality->find(f_cpersonalityname); + + // if personality found in map + if (m_pmPersonality->end() != l_itPersonality) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Personality found in map"); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Personality not found in map"); + + l_estatus = CreatePersonality(f_cpersonalityname); + } + + m_cCurrentPersonality = f_cpersonalityname; + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "map object is NULL"); // LCOV_EXCL_LINE 6: m_pmPersonality can't be NULL + } + } else { + l_estatus = eFrameworkunifiedStatusInvldParam; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CreatePersonality +/// This function is used to create new Personality. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CnotificationpersistentservicePersonalizationManager::CreatePersonality(const std::string &f_cpersonalityname) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != m_pmPersonality) { // LCOV_EXCL_BR_LINE 6: m_pmPersonality can't be NULL + CNotificationpersistentservicePersonality *l_pPersonality = new(std::nothrow) CNotificationpersistentservicePersonality(); // LCOV_EXCL_BR_LINE 11: unexpected branch + + if (NULL != l_pPersonality) { // LCOV_EXCL_BR_LINE 5: It's impossible to mock new() function + l_pPersonality->m_uiUserId = ++m_uiUserId; + l_pPersonality->m_cUserName = f_cpersonalityname; + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Inserting new personality in map"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + m_pmPersonality->insert(make_pair(f_cpersonalityname, l_pPersonality)); + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "map object is NULL"); // LCOV_EXCL_LINE 6: m_pmPersonality can't be NULL + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// NotificationpersistentserviceIsValidPersonality +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +BOOL CnotificationpersistentservicePersonalizationManager::NotificationpersistentserviceIsValidPersonality(const std::string f_cpersonalityname) { + BOOL l_bReturnValue = FALSE; + // iterator to find personality name from map of personality + Personality_Type::iterator l_itPersonality; + if (NULL != m_pmPersonality) { // LCOV_EXCL_BR_LINE 6: m_pmPersonality can't be NULL + l_itPersonality = m_pmPersonality->find(f_cpersonalityname); + + // if personality found in map + if (m_pmPersonality->end() != l_itPersonality) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Personality found in map"); + l_bReturnValue = TRUE; + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Personality not found in map"); + } + } else { + // LCOV_EXCL_START 6: m_pmPersonality can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "map object is NULL"); + // LCOV_EXCL_STOP + } + + return l_bReturnValue; +} diff --git a/service/native/notification_persistent_service/server/src/ns_npp_registry_entry.cpp b/service/native/notification_persistent_service/server/src/ns_npp_registry_entry.cpp new file mode 100755 index 0000000..dc74580 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_registry_entry.cpp @@ -0,0 +1,333 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NPPService +/// \brief The file contains declaration of CRegistryEntry class. +/// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_registry_entry.h" + +//////////////////////////////////////////////////////////////////////////////////////////// +/// Constructor +//////////////////////////////////////////////////////////////////////////////////////////// +CRegistryEntry::CRegistryEntry(const std::string &f_ctag, const std::string &f_crequester, + const std::string &f_cstoragepath, + const BOOL f_bisuserpersistence): + m_eJobState(ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATEIDLE), + m_cTag(f_ctag), + m_cRequestor(f_crequester), + m_bIsReleased(FALSE), + m_bIsPersisted(FALSE), + m_bIsUserPersistence(f_bisuserpersistence), + m_eCurrentAction(LOADTYPE_NONE), + m_ePersistType(ENOTIFICATIONPERSISTENTSERVICEPERSISTNONE), + m_ePersistCategory(eFrameworkunifiedUserData) { + m_cBasePath.clear(); + + // set base path. + m_cBasePath += f_cstoragepath; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// Copy Constructor +//////////////////////////////////////////////////////////////////////////////////////////// +CRegistryEntry::CRegistryEntry(const CRegistryEntry &in): + m_eJobState(ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATEIDLE), + m_cTag(in.m_cTag), + m_cRequestor(in.m_cRequestor), + m_bIsReleased(in.m_bIsReleased), + m_bIsPersisted(in.m_bIsPersisted), + m_cPersistPath(in.m_cPersistPath), + m_cBasePath(in.m_cBasePath), + m_bIsUserPersistence(in.m_bIsUserPersistence), + m_eCurrentAction(in.m_eCurrentAction), + m_ePersistType(in.m_ePersistType), + m_ePersistCategory(in.m_ePersistCategory) { +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// Operator overload +/// +//////////////////////////////////////////////////////////////////////////////////////////// +CRegistryEntry &CRegistryEntry::operator=(const CRegistryEntry &in) { // LCOV_EXCL_START 8: never be used + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + if (this != &in) { + m_eJobState = in.m_eJobState; + m_cTag = in.m_cTag; + m_cRequestor = in.m_cRequestor; + m_bIsReleased = in.m_bIsReleased; + m_bIsPersisted = in.m_bIsPersisted; + m_cPersistPath = in.m_cPersistPath; + m_cBasePath = in.m_cBasePath; + m_bIsUserPersistence = in.m_bIsUserPersistence; + m_ePersistType = in.m_ePersistType; + } + return *this; +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////// +/// SetReleasePath +/// Set release path. +//////////////////////////////////////////////////////////////////////////////////////////// +VOID CRegistryEntry::SetReleasePath(const std::string &f_creleasepath) { + m_bIsReleased = TRUE; + m_cReleasePath = f_creleasepath; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// SetBeingPersisted +/// Set the file/folder is being persisted. +//////////////////////////////////////////////////////////////////////////////////////////// +VOID CRegistryEntry::SetBeingPersisted() { + if (LOADTYPE_RELEASE == m_eCurrentAction) { + m_bIsPersisted = TRUE; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// IsReleased +/// File/folder released or not. +//////////////////////////////////////////////////////////////////////////////////////////// +BOOL CRegistryEntry::IsReleased() const { + return m_bIsReleased; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// HasntBeenPersisted +/// File/Folder persisted or not +//////////////////////////////////////////////////////////////////////////////////////////// +BOOL CRegistryEntry::HasntBeenPersisted() const { + return !m_bIsPersisted; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// IsPersisted +/// File persisted or not +//////////////////////////////////////////////////////////////////////////////////////////// +BOOL CRegistryEntry::IsPersisted() const { + return m_bIsPersisted; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// GetPersistPath +/// Get the persist path. +//////////////////////////////////////////////////////////////////////////////////////////// +std::string CRegistryEntry::GetPersistPath() const { + return m_cPersistPath; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// GetReleasePath +/// Get the release path. +//////////////////////////////////////////////////////////////////////////////////////////// +std::string CRegistryEntry::GetReleasePath() const { + return m_cReleasePath; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// GetLoadPath +/// Get the load path. +//////////////////////////////////////////////////////////////////////////////////////////// +std::string CRegistryEntry::GetLoadPath(ENotificationpersistentservicePersistType f_epersisttype, std::string f_cusername) const { + std::string l_cLoadPath = ""; + + if (f_epersisttype > ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST && f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST) { // LCOV_EXCL_BR_LINE 6: f_epersisttype must be in range. // NOLINT[whitespace/line_length] + l_cLoadPath = m_cBasePath; + + switch (m_ePersistCategory) { + case eFrameworkunifiedUserData: { + l_cLoadPath += USERDATADIR; + + // Check if to persist for user + if (m_bIsUserPersistence) { + // if its a user file, user name can't be empty + if (!f_cusername.empty()) { // LCOV_EXCL_BR_LINE 6: f_cusername can't be empty + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Tag %s is registered for user %s", m_cTag.c_str(), f_cusername.c_str()); + l_cLoadPath += f_cusername; + l_cLoadPath += "/"; + } + } else { + l_cLoadPath += ALLUSERAPPDATADIR; + } + + break; + } + case eFrameworkunifiedFactoryData: { + l_cLoadPath += FACTORYDATADIR; + break; + } + case eFrameworkunifiedFactoryCustomerData: { + l_cLoadPath += FACTORYCUSTOMERDATADIR; + break; + } + case eFrameworkunifiedDealerData: { + l_cLoadPath += DEALERDATADIR; + break; + } + } + + l_cLoadPath += m_cRequestor; + l_cLoadPath += "/"; + + // file and folder persistency has different storage paths mapped + if (ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE == f_epersisttype) { + l_cLoadPath += "NSFile/"; + } else if (ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER == f_epersisttype) { // LCOV_EXCL_BR_LINE 6: f_epersisttype must be ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE or ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER. // NOLINT[whitespace/line_length] + l_cLoadPath += "NSFolder/"; + } + + l_cLoadPath += m_cTag; + } + + return l_cLoadPath; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// GetRequester +/// Get the name of requester. +//////////////////////////////////////////////////////////////////////////////////////////// +std::string CRegistryEntry::GetRequester() const { + return m_cRequestor; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// GetTag +/// Get the tag. +//////////////////////////////////////////////////////////////////////////////////////////// +std::string CRegistryEntry::GetTag() const { + return m_cTag; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// IsUserPersistence +/// +//////////////////////////////////////////////////////////////////////////////////////////// +BOOL CRegistryEntry::IsUserPersistence() { + return m_bIsUserPersistence; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// SetCurrentAction +/// +//////////////////////////////////////////////////////////////////////////////////////////// +VOID CRegistryEntry::SetCurrentAction(ENPS_Loadtype f_ecurrentaction) { + m_eCurrentAction = f_ecurrentaction; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// ResetPersistedFlag +/// +//////////////////////////////////////////////////////////////////////////////////////////// +VOID CRegistryEntry::ResetPersistedFlag() { + m_bIsPersisted = FALSE; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// SetPersistProperties +/// +//////////////////////////////////////////////////////////////////////////////////////////// +VOID CRegistryEntry::SetPersistProperties(ENotificationpersistentservicePersistType f_epersisttype, std::string f_cusername) { + if (f_epersisttype > ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST && f_epersisttype < ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST) { // LCOV_EXCL_BR_LINE 6: f_epersisttype must be in range. // NOLINT[whitespace/line_length] + // set the persist type + m_ePersistType = f_epersisttype; + + // set the persist file based on the persist type and username (if a user file) + m_cPersistPath = m_cBasePath; + + switch (m_ePersistCategory) { + case eFrameworkunifiedUserData: { + m_cPersistPath += USERDATADIR; + + // Check if to persist for user + if (m_bIsUserPersistence) { + // if its a user file, user name can't be empty + if (!f_cusername.empty()) { // LCOV_EXCL_BR_LINE 6: f_cusername can't be empty + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Tag %s is registered for user %s", m_cTag.c_str(), f_cusername.c_str()); + m_cPersistPath += f_cusername; + m_cPersistPath += "/"; + } + } else { + m_cPersistPath += ALLUSERAPPDATADIR; + } + + break; + } + case eFrameworkunifiedFactoryData: { + m_cPersistPath += FACTORYDATADIR; + break; + } + case eFrameworkunifiedFactoryCustomerData: { + m_cPersistPath += FACTORYCUSTOMERDATADIR; + break; + } + case eFrameworkunifiedDealerData: { + m_cPersistPath += DEALERDATADIR; + break; + } + } + + m_cPersistPath += m_cRequestor; + m_cPersistPath += "/"; + + // file and folder persistency has different storage paths mapped + if (ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE == f_epersisttype) { + m_cPersistPath += "NSFile/"; + } else if (ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER == f_epersisttype) { // LCOV_EXCL_BR_LINE 6: f_epersisttype must be ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE or ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER. // NOLINT[whitespace/line_length] + m_cPersistPath += "NSFolder/"; + } + + m_cPersistPath += m_cTag; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// GetPersistType +/// +//////////////////////////////////////////////////////////////////////////////////////////// +ENotificationpersistentservicePersistType CRegistryEntry::GetPersistType() const { + return m_ePersistType; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// SetPersistentCategory +/// Sets the persistent type related to tag +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CRegistryEntry::SetPersistentCategory(EFrameworkunifiedPersistCategory f_epersistcategory) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + m_ePersistCategory = f_epersistcategory; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////// +/// GetPersistentCategory +/// Gets the persistent type of a tag +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedPersistCategory CRegistryEntry::GetPersistentCategory() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return m_ePersistCategory; +} diff --git a/service/native/notification_persistent_service/server/src/ns_npp_regular_notification.cpp b/service/native/notification_persistent_service/server/src/ns_npp_regular_notification.cpp new file mode 100755 index 0000000..6d75091 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_regular_notification.cpp @@ -0,0 +1,158 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CRegularNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// + + +#include +#include +#include +#include +#include +#include +#include +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_regular_notification.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CRegularNotification +/// Constructor of CRegularNotification class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CRegularNotification::CRegularNotification(const std::string &f_cnotificationname, + const UI_32 f_uimaxmsgsize): + CNotification(f_cnotificationname, f_uimaxmsgsize) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_ePersistentType = eFrameworkunifiedNotificationVar; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CRegularNotification +/// Destructor of CRegularNotification class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CRegularNotification::~CRegularNotification() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// AddEventReciever +/// This function adds the name of the application to receiver list of particular notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CRegularNotification::AddEventReciever(const std::string &f_csubscribername) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (!f_csubscribername.empty()) { // LCOV_EXCL_BR_LINE 6: double check, f_csubscribername can't be empty + l_estatus = AddReceiverInMap(f_csubscribername); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusInvldParam; // LCOV_EXCL_LINE 6: f_csubscribername can't be empty + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// Publish +/// This function publishes the notification to subscribed clients. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CRegularNotification::Publish(const std::string &f_cservicename, + PVOID f_pmessage, + const UI_32 f_uimsgsize) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // Message Queue Handle + HANDLE l_hMsgQHandle = NULL; + + // Pointer to class CNotificationReceiver + CNotificationReceiver *l_pNotificationReceiver = NULL; + + // Iterator for Notification Receiver map + NotifReceiver_Iterator_Type l_itrNotifReceiver; + + if (m_uiMaxMsgSize >= f_uimsgsize) { + if (0 == m_cServiceName.compare(f_cservicename)) { + for (l_itrNotifReceiver = m_pmSubscribersList->begin(); + l_itrNotifReceiver != m_pmSubscribersList->end(); + l_itrNotifReceiver++) { + l_pNotificationReceiver = l_itrNotifReceiver->second; + + if (NULL != l_pNotificationReceiver) { // LCOV_EXCL_BR_LINE 6: l_pNotificationReceiver can't be NULL + l_hMsgQHandle = l_pNotificationReceiver->m_MsgQHandle; + + if (NULL != l_hMsgQHandle) { // LCOV_EXCL_BR_LINE 6: l_hMsgQHandle can't be NULL + if (eFrameworkunifiedStatusOK != (l_estatus = PublishData(l_hMsgQHandle, f_pmessage, f_uimsgsize))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error Publishing notification %s to %s published by %s, error status: 0x%x", + m_cNotificationName.c_str(), l_itrNotifReceiver->first.c_str(), f_cservicename.c_str(), l_estatus); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: l_hMsgQHandle can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "MsgQ Handle NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: l_pNotificationReceiver can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pNotificationReceiver is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't publish notification %s. Registered by %s and published by %s.", + m_cNotificationName.c_str(), m_cServiceName.c_str(), f_cservicename.c_str()); // LCOV_EXCL_BR_LINE 15: marco defined in "native_service/ns_logger_if.h" + l_estatus = eFrameworkunifiedStatusInvldParam; + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't publish notification %s. Message data size (%d) is greater than maximum registered data size (%d)", + m_cNotificationName.c_str(), f_uimsgsize, m_uiMaxMsgSize); + l_estatus = eFrameworkunifiedStatusFail; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} diff --git a/service/native/notification_persistent_service/server/src/ns_npp_state_nor_persistence_notification.cpp b/service/native/notification_persistent_service/server/src/ns_npp_state_nor_persistence_notification.cpp new file mode 100755 index 0000000..7898f38 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_state_nor_persistence_notification.cpp @@ -0,0 +1,305 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CStateNorPersistenceNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include +#include +#include +#include + +#include "ns_npp_types.h" +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_persistent_data.h" +#include "ns_npp_state_nor_persistence_notification.h" + +HANDLE CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread = NULL; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CStateNorPersistenceNotification +/// Constructor of CStateNorPersistenceNotification class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CStateNorPersistenceNotification::CStateNorPersistenceNotification(const std::string &f_cnotificationname, + const UI_32 f_uimaxmsgsize, + const UI_32 f_uidelay, + const EFrameworkunifiedPersistCategory f_epersistcategory): + CStateNotification(f_cnotificationname, f_uimaxmsgsize), + m_uiDelay(f_uidelay), + m_ePersistCategory(f_epersistcategory) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_ePersistentType = eFrameworkunifiedImmediatePersistedStateVar; + + // also, register the notification with worker thread responsible for writing notification data + if (NULL != CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread) { // LCOV_EXCL_BR_LINE 6: CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread can not be null // NOLINT[whitespace/line_length] + TImmediatePersistenceRegisterNotifInfo l_tRegisterNotifInfo = {}; + std::strncpy(l_tRegisterNotifInfo.m_cnotificationname, + f_cnotificationname.c_str(), + sizeof(l_tRegisterNotifInfo.m_cnotificationname) - 1); + l_tRegisterNotifInfo.m_uidelay = f_uidelay; + l_tRegisterNotifInfo.m_epersistcategory = f_epersistcategory; + + if (eFrameworkunifiedStatusOK != McSend(CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread, AppName, NOR_PERSISTENCE_REGISTER, sizeof(l_tRegisterNotifInfo), &l_tRegisterNotifInfo)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "McSend for cmd 0x%X failed", NOR_PERSISTENCE_REGISTER); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CStateNorPersistenceNotification +/// Constructor of CStateNorPersistenceNotification class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CStateNorPersistenceNotification::~CStateNorPersistenceNotification() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // also, unregister the notification with worker thread responsible for writing notification data + if (NULL != CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread) { // LCOV_EXCL_BR_LINE 6: CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread can not be null // NOLINT[whitespace/line_length] + TImmediatePersistenceUnregisterNotifInfo l_tUnregisterNotifInfo = {}; + std::strncpy(l_tUnregisterNotifInfo.m_cnotificationname, + GetNotificationName().c_str(), // LCOV_EXCL_BR_LINE 11: except,C++ STL + sizeof(l_tUnregisterNotifInfo.m_cnotificationname) - 1); + + if (eFrameworkunifiedStatusOK != McSend(CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread, AppName, NOR_PERSISTENCE_UNREGISTER, sizeof(l_tUnregisterNotifInfo), &l_tUnregisterNotifInfo)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "McSend for cmd 0x%X failed", NOR_PERSISTENCE_UNREGISTER); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// GetPersistenceDelay +/// Method to get the persistence time delay. +//////////////////////////////////////////////////////////////////////////////////////////////////// +UI_32 CStateNorPersistenceNotification::GetPersistenceDelay() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return m_uiDelay; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// Publish +/// This function publishes the notification to subscribed clients and saves the data +/// immediately to persistent memory. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CStateNorPersistenceNotification::Publish(const std::string &f_cservicename, + PVOID f_pmessage, + const UI_32 f_uimsgsize) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (eFrameworkunifiedStatusOK == (l_estatus = PublishNotification(f_cservicename, + f_pmessage, + f_uimsgsize))) { + if (eFrameworkunifiedStatusOK != (l_estatus = SaveDataToNor(f_pmessage, f_uimsgsize))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error in saving persistent data on nor for %s published by %s, status: %d", + m_cNotificationName.c_str(), f_cservicename.c_str(), l_estatus); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// PublishNotification +/// This function publishes the notification to subscribed clients. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CStateNorPersistenceNotification::PublishNotification(const std::string &f_cservicename, + PVOID f_pmessage, + const UI_32 f_uimsgsize) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + l_estatus = CStateNotification::Publish(f_cservicename, f_pmessage, f_uimsgsize); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SaveDataToNor +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CStateNorPersistenceNotification::SaveDataToNor(PVOID f_pmessage, const UI_32 f_uimsgsize) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != f_pmessage && f_uimsgsize > 0) { + TNorPersistenceNotifInfoHeader l_tNorPersistentData = {}; + UI_32 l_ui32SendDataTotalLength = static_cast(sizeof(TNorPersistenceNotifInfoHeader) + f_uimsgsize); + UI_8 *l_ui8SendData = new(std::nothrow) UI_8[l_ui32SendDataTotalLength]; + UI_8 *l_ui8TmpOffset = l_ui8SendData; + + if (NULL != l_ui8SendData) { // LCOV_EXCL_BR_LINE 6: l_ui8SendData can't be NULL + std::strncpy(l_tNorPersistentData.m_cnotificationname, + this->GetNotificationName().c_str(), + sizeof(l_tNorPersistentData.m_cnotificationname) - 1); + std::strncpy(l_tNorPersistentData.m_cpublishername, + this->GetPublisherName().c_str(), + sizeof(l_tNorPersistentData.m_cpublishername) - 1); + l_tNorPersistentData.m_epersistenttype = this->GetNotificationType(); + l_tNorPersistentData.m_uimaxmsglength = this->GetMaxMessageSize(); + l_tNorPersistentData.m_uidelay = this->GetPersistenceDelay(); + l_tNorPersistentData.m_uimsgsize = f_uimsgsize; + l_tNorPersistentData.m_epersistcategory = m_ePersistCategory; + + std::memset(l_ui8SendData, 0, l_ui32SendDataTotalLength); + std::memcpy(l_ui8SendData, &l_tNorPersistentData, sizeof(l_tNorPersistentData)); + l_ui8TmpOffset += sizeof(l_tNorPersistentData); + std::memcpy(l_ui8TmpOffset, f_pmessage, f_uimsgsize); + + // issue a copy to the worker thread + if (NULL != CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread) { // LCOV_EXCL_BR_LINE 6: CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread can not be null // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK != (l_estatus = McSend(CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread, AppName, NOR_PERSISTENCE_TIMER_START, l_ui32SendDataTotalLength, l_ui8SendData))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "McSend for nor worker thread failed %d ", l_estatus); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + } + } else { + // LCOV_EXCL_START 6: CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread can not be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusInvldHandle; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Sender handle of nor worker thread is NULL. Can't send message."); + // LCOV_EXCL_STOP + } + + delete[] l_ui8SendData; // LCOV_EXCL_BR_LINE 11: unexpected branch + l_ui8SendData = NULL; + } else { + // LCOV_EXCL_START 6: l_ui8SendData can not be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + l_estatus = eFrameworkunifiedStatusInvldParam; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification data is NULL, size is %d", f_uimsgsize); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// GetPersistentCategory +/// Gets the persist type of notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedPersistCategory CStateNorPersistenceNotification::GetPersistentCategory() { // LCOV_EXCL_START 100: never be used + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return m_ePersistCategory; +} +// LCOV_EXCL_STOP + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SetPersistentCategory +/// Sets the persist type of notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CStateNorPersistenceNotification::SetPersistentCategory(const EFrameworkunifiedPersistCategory f_epersistcategory) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (f_epersistcategory != m_ePersistCategory) { + if (NULL != m_pData && NULL != m_pData->m_pMessage) { // LCOV_EXCL_BR_LINE 6: if m_pData is not null, the m_pData->m_pMessage can not be null // NOLINT[whitespace/line_length] + if (NULL != CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread) { // LCOV_EXCL_BR_LINE 6: CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread can not be null // NOLINT[whitespace/line_length] + TImmediatePersistenceChangeCategory l_tChangeCategory = {}; + UI_32 l_ui32SendDataTotalLength = + static_cast(sizeof(TImmediatePersistenceChangeCategory) + m_pData->m_uiMsgSize); + UI_8 *l_ui8SendData = new(std::nothrow) UI_8[l_ui32SendDataTotalLength]; + UI_8 *l_ui8TmpOffset = l_ui8SendData; + + if (NULL != l_ui8SendData) { // LCOV_EXCL_BR_LINE 6: l_ui8SendData can't be NULL + std::strncpy(l_tChangeCategory.m_tnornotifInfoheader.m_cnotificationname, this->GetNotificationName().c_str(), + sizeof(l_tChangeCategory.m_tnornotifInfoheader.m_cnotificationname) - 1); + std::strncpy(l_tChangeCategory.m_tnornotifInfoheader.m_cpublishername, this->GetPublisherName().c_str(), + sizeof(l_tChangeCategory.m_tnornotifInfoheader.m_cpublishername) - 1); + l_tChangeCategory.m_tnornotifInfoheader.m_epersistenttype = this->GetNotificationType(); + l_tChangeCategory.m_tnornotifInfoheader.m_uimaxmsglength = this->GetMaxMessageSize(); + l_tChangeCategory.m_tnornotifInfoheader.m_uidelay = this->GetPersistenceDelay(); + l_tChangeCategory.m_tnornotifInfoheader.m_uimsgsize = m_pData->m_uiMsgSize; + l_tChangeCategory.m_tnornotifInfoheader.m_epersistcategory = f_epersistcategory; + + l_tChangeCategory.m_eoldpersistcategory = m_ePersistCategory; + + std::memset(l_ui8SendData, 0, l_ui32SendDataTotalLength); + std::memcpy(l_ui8SendData, &l_tChangeCategory, sizeof(l_tChangeCategory)); + l_ui8TmpOffset += sizeof(l_tChangeCategory); + std::memcpy(l_ui8TmpOffset, m_pData->m_pMessage, m_pData->m_uiMsgSize); + + // issue a copy to the worker thread + if (eFrameworkunifiedStatusOK != (l_estatus = McSend(CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread, // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + AppName, + NOR_PERSISTENCE_CHANGE_CATEGORY, + l_ui32SendDataTotalLength, + l_ui8SendData))) { + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "McSend failed while changing category for notfn %s from %d to %d, status=%d", + m_cNotificationName.c_str(), m_ePersistCategory, f_epersistcategory, l_estatus); + // LCOV_EXCL_STOP + } else { + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, + "Msg sent to immediate pers. thread to change persist category of %s from %d to %d", + m_cNotificationName.c_str(), m_ePersistCategory, f_epersistcategory); + } + + delete[] l_ui8SendData; + l_ui8SendData = NULL; + } else { + // LCOV_EXCL_START 6: l_ui8SendData can not be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Memory alloc error for l_ui8SendData, errno=%d", errno); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread can not be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Sender handle of nor worker thread is NULL. Can't send message."); + l_estatus = eFrameworkunifiedStatusInvldHandle; + // LCOV_EXCL_STOP + } + } else { // no data is persisted in emmc for this notfn, so no need to send msg to worker thread + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Notfn %s has no data to persist", m_cNotificationName.c_str()); + } + + m_ePersistCategory = f_epersistcategory; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} diff --git a/service/native/notification_persistent_service/server/src/ns_npp_state_notification.cpp b/service/native/notification_persistent_service/server/src/ns_npp_state_notification.cpp new file mode 100755 index 0000000..ff8f054 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_state_notification.cpp @@ -0,0 +1,402 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CStateNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include +#include +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_persistent_data.h" +#include "ns_npp_state_notification.h" + + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CStateNotification +/// Constructor of CStateNotification class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CStateNotification::CStateNotification(const std::string &f_cnotificationname, + const UI_32 f_uimaxmsgsize): + CNotification(f_cnotificationname, f_uimaxmsgsize), + m_pData(NULL), + m_pDefaultData(NULL), + m_bWasPublished(FALSE) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_ePersistentType = eFrameworkunifiedStateVar; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CStateNotification +/// Destructor of CStateNotification class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CStateNotification::~CStateNotification() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != m_pData) { + delete m_pData; // LCOV_EXCL_BR_LINE 11: unexpected branch + m_pData = NULL; + } + + if (NULL != m_pDefaultData) { + delete m_pDefaultData; + m_pDefaultData = NULL; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// GetPersistentData +/// This function is used to get the persistent data pointer +//////////////////////////////////////////////////////////////////////////////////////////////////// +const CPersistentData *CStateNotification::GetPersistentData() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + + return m_pData; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SetPersistentData +/// This function is used to set the data related to notification +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CStateNotification::SetPersistentData(PVOID f_pmessage, + const UI_32 f_msgsize) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL == m_pData) { + m_pData = new(std::nothrow) CPersistentData(); // LCOV_EXCL_BR_LINE 11: unexpected branch + } + + l_estatus = SetData(m_pData, f_pmessage, f_msgsize); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// GetDefaultPersistentData +/// This function get the default data(if any) related to notification +//////////////////////////////////////////////////////////////////////////////////////////////////// +const CPersistentData *CStateNotification::GetDefaultPersistentData() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + + return m_pDefaultData; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SetDefaultPersistentData +/// This function is used to set the default data related to notification +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CStateNotification::SetDefaultPersistentData(PVOID f_pmessage, + const UI_32 f_msgsize) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL == m_pDefaultData) { + m_pDefaultData = new(std::nothrow) CPersistentData(); // LCOV_EXCL_BR_LINE 11: except,C++ STL + } + + // set the default persistent data + if (eFrameworkunifiedStatusOK == (l_estatus = SetData(m_pDefaultData, f_pmessage, f_msgsize))) { + if (NULL == m_pData) { + // set the default data as persistent data if notification is not yet published + l_estatus = SetPersistentData(f_pmessage, f_msgsize); + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Setting Persistent data"); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistent data already set"); + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error setting default persistent data for notification:: %s", + m_cNotificationName.c_str()); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SetData +/// This function is used to set the persistent data +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CStateNotification::SetData(CPersistentData *f_pdata, + PVOID f_pmessage, + const UI_32 f_msgsize) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (NULL != f_pdata) { // LCOV_EXCL_BR_LINE 6: double check, f_pdata can't be NULL + if (m_uiMaxMsgSize >= f_msgsize) { + f_pdata->m_uiMsgSize = f_msgsize; + + if (NULL != f_pmessage && 0 != f_msgsize) { + if (NULL == f_pdata->m_pMessage) { + f_pdata->m_pMessage = new(std::nothrow) CHAR[m_uiMaxMsgSize]; + } + + if (NULL != f_pdata->m_pMessage) { // LCOV_EXCL_BR_LINE 5: new error case + std::memset(f_pdata->m_pMessage, 0, m_uiMaxMsgSize); + std::memcpy(f_pdata->m_pMessage, f_pmessage, f_msgsize); + } else { + // LCOV_EXCL_START 5: new error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Memory allocation error, unable to set persistent data for notification: %s", + m_cNotificationName.c_str()); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + if (NULL != f_pdata->m_pMessage) { + delete[](static_cast(f_pdata->m_pMessage)); + f_pdata->m_pMessage = NULL; + } + } + + m_bWasPublished = TRUE; + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't set notification data. Message data size (%d) is greater than maximum registered data size (%d)" + " of notification (%s).", f_msgsize, m_uiMaxMsgSize, GetNotificationName().c_str()); + l_estatus = eFrameworkunifiedStatusFail; + } + } else { + // LCOV_EXCL_START 6: double check, f_pdata can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to set persistent data for notification: %s, persistent object is NULL", + m_cNotificationName.c_str()); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// AddEventReciever +/// This function adds the name of the application to receiver list of particular notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CStateNotification::AddEventReciever(const std::string &f_csubscribername) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // Message Queue Handle + HANDLE l_hMsgQHandle = NULL; + + // iterator of CNotificationReceiver map + NotifReceiver_Iterator_Type l_iterator; + + CNotificationReceiver *l_pNotificationReceiver = NULL; + + if (!f_csubscribername.empty()) { // LCOV_EXCL_BR_LINE 6: double check, f_csubscribername can't be empty + l_estatus = AddReceiverInMap(f_csubscribername); + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusInvldParam; // LCOV_EXCL_LINE 6: double check, f_csubscribername can't be empty + } + + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 6: double check, l_estatus must be eFrameworkunifiedStatusOK + if (m_bWasPublished) { + FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Republish Notification to subscriber :: %s", f_csubscribername.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] + + if (NULL != m_pData) { + l_iterator = m_pmSubscribersList->find(f_csubscribername); + + if (m_pmSubscribersList->end() != l_iterator) { + l_pNotificationReceiver = (*l_iterator).second; + + if (NULL != l_pNotificationReceiver) { // LCOV_EXCL_BR_LINE 6: double check, l_pNotificationReceiver can't be NULL // NOLINT[whitespace/line_length] + l_hMsgQHandle = l_pNotificationReceiver->m_MsgQHandle; + + if (NULL != l_hMsgQHandle) { // LCOV_EXCL_BR_LINE 6: double check, l_hMsgQHandle can't be NULL + if (eFrameworkunifiedStatusOK != (l_estatus = PublishData(l_pNotificationReceiver->m_MsgQHandle, m_pData->m_pMessage, m_pData->m_uiMsgSize))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error Publishing notification %s to %s published by %s, error status: 0x%x", + m_cNotificationName.c_str(), l_iterator->first.c_str(), m_cServiceName.c_str(), l_estatus); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: double check, l_hMsgQHandle can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "MsgQ Handle NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: double check, l_pNotificationReceiver can't be NULL + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pNotificationReceiver is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "m_pData pointer is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Subscribing Notfn, src=%s name=%s. Notification not published.", + f_csubscribername.c_str(), m_cNotificationName.c_str()); + } + } else { + // LCOV_EXCL_START 6: double check, l_estatus must be eFrameworkunifiedStatusOK + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + l_estatus = eFrameworkunifiedStatusFail; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Receiver Not Added in map"); + // LCOV_EXCL_STOP + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// Publish +/// This function publishes the notification to subscribed clients. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CStateNotification::Publish(const std::string &f_cservicename, + PVOID f_pmessage, + const UI_32 f_uimsgsize) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // Message Queue Handle + HANDLE l_hMsgQHandle = NULL; + + // Pointer to class CNotificationReceiver + CNotificationReceiver *l_pNotificationReceiver = NULL; + + // Iterator for Notification Receiver map + NotifReceiver_Iterator_Type l_itrNotifReceiver; + + if (m_uiMaxMsgSize >= f_uimsgsize) { + if (0 == m_cServiceName.compare(f_cservicename)) { + l_estatus = SetPersistentData(f_pmessage, + f_uimsgsize); + + if (eFrameworkunifiedStatusOK == l_estatus) { // LCOV_EXCL_BR_LINE 6: l_estatus is always eFrameworkunifiedStatusOK + for (l_itrNotifReceiver = m_pmSubscribersList->begin(); + l_itrNotifReceiver != m_pmSubscribersList->end(); + l_itrNotifReceiver++) { + l_pNotificationReceiver = l_itrNotifReceiver->second; + + if (NULL != l_pNotificationReceiver) { // LCOV_EXCL_BR_LINE 6:double check, l_pNotificationReceiver can not be null // NOLINT[whitespace/line_length] + l_hMsgQHandle = l_pNotificationReceiver->m_MsgQHandle; + + if (NULL != l_hMsgQHandle && NULL != m_pData) { // LCOV_EXCL_BR_LINE 6:double check, l_hMsgQHandle and m_pData can not be null // NOLINT[whitespace/line_length] + if (eFrameworkunifiedStatusOK != (l_estatus = PublishData(l_hMsgQHandle, m_pData->m_pMessage, f_uimsgsize))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + // LCOV_EXCL_START 4: NSFW error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Error Publishing notification %s to %s published by %s, error status: 0x%x", + m_cNotificationName.c_str(), + l_itrNotifReceiver->first.c_str(), + f_cservicename.c_str(), l_estatus); + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: double check, l_hMsgQHandle and m_pData can not be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "MsgQ Handle NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } else { + // LCOV_EXCL_START 6: double check, l_pNotificationReceiver can not be null + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pNotificationReceiver is NULL"); + l_estatus = eFrameworkunifiedStatusNullPointer; + // LCOV_EXCL_STOP + } + } + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistent Data Not Set"); // LCOV_EXCL_LINE 6: double check, l_estatus is always eFrameworkunifiedStatusOK // NOLINT[whitespace/line_length] + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't publish notification %s. Registered by %s and published by %s.", + GetNotificationName().c_str(), m_cServiceName.c_str(), f_cservicename.c_str()); + l_estatus = eFrameworkunifiedStatusInvldParam; + } + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + "Can't publish notification %s. Message data size (%d) is greater than maximum registered data size (%d)", + GetNotificationName().c_str(), f_uimsgsize, m_uiMaxMsgSize); + l_estatus = eFrameworkunifiedStatusFail; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// IsPublished +/// This functions returns the published status of notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +BOOL CStateNotification::IsPublished() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + return m_bWasPublished; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// ResetMaxMessageSize +/// This function reset the max size of data that can be published with notification. +/// Also deletes the old persistent data and default data. +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CStateNotification::ResetMaxMessageSize(const UI_32 f_uilength) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CNotification::ResetMaxMessageSize(f_uilength); + + // delete the old data as the size is changed the data may become invalid + if (NULL != m_pData) { + delete m_pData; + m_pData = NULL; + } + + if (NULL != m_pDefaultData) { + delete m_pDefaultData; + m_pDefaultData = NULL; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} diff --git a/service/native/notification_persistent_service/server/src/ns_npp_state_persistence_notification.cpp b/service/native/notification_persistent_service/server/src/ns_npp_state_persistence_notification.cpp new file mode 100755 index 0000000..1bb9dd1 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_state_persistence_notification.cpp @@ -0,0 +1,87 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CStatePersistenceNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include +#include +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_state_persistence_notification.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CStatePersistenceNotification +/// Constructor of CStatePersistenceNotification class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CStatePersistenceNotification::CStatePersistenceNotification(const std::string &f_cnotificationname, + const UI_32 f_uimaxmsgsize, + const EFrameworkunifiedPersistCategory f_epersistcategory): + CStateNotification(f_cnotificationname, f_uimaxmsgsize), + m_ePersistCategory(f_epersistcategory) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_ePersistentType = eFrameworkunifiedPersistedStateVar; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CStatePersistenceNotification +/// Constructor of CStatePersistenceNotification class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CStatePersistenceNotification::~CStatePersistenceNotification() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// GetPersistentCategory +/// Gets the persist type of notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedPersistCategory CStatePersistenceNotification::GetPersistentCategory() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return m_ePersistCategory; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// SetPersistentCategory +/// Sets the persist type of notification. +//////////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus CStatePersistenceNotification::SetPersistentCategory(const EFrameworkunifiedPersistCategory f_epersistcategory) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_ePersistCategory = f_epersistcategory; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_estatus; +} diff --git a/service/native/notification_persistent_service/server/src/ns_npp_state_persistence_user_notification.cpp b/service/native/notification_persistent_service/server/src/ns_npp_state_persistence_user_notification.cpp new file mode 100755 index 0000000..222ada3 --- /dev/null +++ b/service/native/notification_persistent_service/server/src/ns_npp_state_persistence_user_notification.cpp @@ -0,0 +1,61 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \defgroup <> <> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CStatePersistenceUserNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include +#include +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_state_persistence_user_notification.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// CStatePersistenceUserNotification +/// Constructor of CStatePersistenceUserNotification class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CStatePersistenceUserNotification::CStatePersistenceUserNotification(const std::string &f_cnotificationname, + const UI_32 f_uimaxmsgsize): + CStateNotification(f_cnotificationname, f_uimaxmsgsize) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + m_ePersistentType = eFrameworkunifiedPersistedStateUserVar; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// ~CStatePersistenceUserNotification +/// Destructor of CStatePersistenceUserNotification class +//////////////////////////////////////////////////////////////////////////////////////////////////// +CStatePersistenceUserNotification::~CStatePersistenceUserNotification() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} -- cgit 1.2.3-korg