diff options
Diffstat (limited to 'nsframework/notification_persistent_service')
57 files changed, 19737 insertions, 0 deletions
diff --git a/nsframework/notification_persistent_service/LICENSE b/nsframework/notification_persistent_service/LICENSE new file mode 100644 index 00000000..f433b1a5 --- /dev/null +++ b/nsframework/notification_persistent_service/LICENSE @@ -0,0 +1,177 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/nsframework/notification_persistent_service/Makefile.server b/nsframework/notification_persistent_service/Makefile.server new file mode 100644 index 00000000..13475190 --- /dev/null +++ b/nsframework/notification_persistent_service/Makefile.server @@ -0,0 +1,19 @@ +# +# @copyright Copyright (c) 2017-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. +# + +SUBDIRS := server + +include ../native_service.mk diff --git a/nsframework/notification_persistent_service/server/Makefile b/nsframework/notification_persistent_service/server/Makefile new file mode 100644 index 00000000..b5b80cb9 --- /dev/null +++ b/nsframework/notification_persistent_service/server/Makefile @@ -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. +# + +######### installed program ############# +INST_PROGS = NS_NPPService + +######### add source path ############# +VPATH += ./src +VPATH += ./include/$(COMPONENT_NAME) + +######### installed library(*.a) ############# +#INST_LIBS = + +######### installed shared library(*.so) ############# +#INST_SHLIBS = + +######### install headers(*.h) ############# +INST_HEADERS = notification_persistent_service.h + +######### compiled sources ############# +NS_NPPService_SRCS = app_states.cpp \ + ns_npp.cpp \ + ns_npp_archive.cpp \ + ns_npp_binary_accesser.cpp \ + ns_npp_copy_worker.cpp \ + ns_npp_fs_directory.cpp \ + ns_npp_handlelist.cpp \ + ns_npp_nor_persistence_worker_thread.cpp \ + ns_npp_notification.cpp \ + ns_npp_notification_manager.cpp \ + ns_npp_notification_receiver.cpp \ + ns_npp_persist_file.cpp \ + ns_npp_persist_folder.cpp \ + ns_npp_persistence.cpp \ + ns_npp_persistence_manager.cpp \ + ns_npp_persistent_data.cpp \ + ns_npp_personalization_manager.cpp \ + ns_npp_registry_entry.cpp \ + ns_npp_regular_notification.cpp \ + ns_npp_state_nor_persistence_notification.cpp \ + ns_npp_state_notification.cpp \ + ns_npp_state_persistence_notification.cpp \ + ns_npp_state_persistence_user_notification.cpp \ + notificationpersistentservice_application.cpp \ + notificationpersistentservice_main.cpp + +######### add include path ############# +CPPFLAGS += -I./include +CPPFLAGS += -Wl,--no-undefined +CPPFLAGS += -Werror=implicit-function-declaration +CPPFLAGS += -Werror=format-security + +CPPFLAGS += -Wconversion +CPPFLAGS += -Wint-to-pointer-cast +CPPFLAGS += -Wpointer-arith +CPPFLAGS += -Wformat +######### add compile option ############# +ENABLE_PARA_INST += install-prog # PARALLEL MAKE +CPPFLAGS += -DIMPL_AGL_APPLICATION_CALLBACKS_PRE_BACKGROUND + +######### linked library ############# + +######### linked library (dynamic) ############# +LDFLAGS += -Wl,--no-as-needed +LDLIBS += -Wl,-Bdynamic -lNS_FrameworkUnified +LDLIBS += -Wl,-Bdynamic -ltar +LDLIBS += -Wl,-Bdynamic -lz +LDLIBS += -Wl,-Bdynamic -lPosixBasedOS001legacy #-lPosixBasedOS001ClockCycleApi -lPosixBasedOS001MsgApi -lPosixBasedOS001GetPrioApi -lPosixBasedOS001TimeApi -lPosixBasedOS001SlogApi + +LINK_CXX=Y + +######### add library path ############# + +include ../../native_service.mk diff --git a/nsframework/notification_persistent_service/server/include/app_states.h b/nsframework/notification_persistent_service/server/include/app_states.h new file mode 100644 index 00000000..a7f4b4a0 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/app_states.h @@ -0,0 +1,187 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file all the states, events, internal transitions of state machine. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_APP_STATES_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_APP_STATES_H_ + +#include <native_service/frameworkunified_sm_framework_if.h> +#include <native_service/ns_np_service.h> +#include <string> + +const UI_32 kCuiEventIdStartLimit = 20; + +DEFINE_COMPOSITESTATE(sNotificationpersistentserviceNPPRoot) // NOLINT (readability/naming) +DEFINE_ORTHOGONALSTATE_OVERRIDE(sNotificationpersistentserviceNPPStart) +DEFINE_LEAFSTATE(sNotificationpersistentserviceNPPError) + +// =====Define Persistence state +DEFINE_LEAFSTATE_OVERRIDE(sNotificationpersistentservicePersistenceReady) +DEFINE_LEAFSTATE(sNotificationpersistentservicePersistenceError) + +// DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnLoadPersistentData) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPReadPersistedData) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPReleaseFileAck) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnSaveDataAck) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPNorDataSaveAck) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnRegisterPersistentFile) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnReleasePersistentFile) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnLoadPersistentFile) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnRegisterPersistentFolder) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnLoadPersistentFolder) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnReleasePersistentFolder) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPSetFilePersistentType) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPSetFolderPersistentType) + +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnUserChange) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceCheckAllReleaseRequestsProcessed) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPPersistentSync) + +// =====Define Shutdown state +DEFINE_LEAFSTATE(sNotificationpersistentserviceShutdownIdle) +// DEFINE_LEAFSTATE_OVERRIDE(sNotificationpersistentserviceShutdownDataSave) +class CsNotificationpersistentserviceShutdownDataSave : public CFrameworkunifiedLeafState { + public: + explicit CsNotificationpersistentserviceShutdownDataSave(std::string f_pName); + virtual ~CsNotificationpersistentserviceShutdownDataSave(); + EFrameworkunifiedStatus FrameworkunifiedOnEntry(CEventDataPtr f_peventdata); + EFrameworkunifiedStatus FrameworkunifiedOnExit(CEventDataPtr f_peventdata); + private: + std::string m_cShutdownRequestor; +}; + +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPShutdown) // NOLINT (readability/naming) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnShutdownTimeout) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceReInitShutdownTimer) + +// =====Define Notification state +DEFINE_LEAFSTATE(sNotificationpersistentserviceNotificationReady) +DEFINE_LEAFSTATE(sNotificationpersistentserviceNotificationError) + +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPPublishNotification) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPRegisterNotifications) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPSubscribeToNotification) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPSubscribeToNotifications) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPUnRegisterNotifications) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPUnSubscribeFromNotification) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPUnSubscribeFromNotifications) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPRegisterImmediateNotifications) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPGetReadyStatus) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPClearPersistedData) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPSetDefaultPersistentData) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPSetNotfnPersistentType) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPPublishImmediateNotification) + +#ifdef NPP_PROFILEINFO_ENABLE + +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPProfileNotifications) +DEFINE_INTERNALTRANSITION(NotificationpersistentserviceOnNPProfilePersistence) + +#endif + +// ==========Define event +DEFINE_EVENT(evIdle, kCuiEventIdStartLimit + 1) +DEFINE_EVENT(evReady, kCuiEventIdStartLimit + 2) +DEFINE_EVENT(evShutdown, kCuiEventIdStartLimit + 3) +DEFINE_EVENT(evError, kCuiEventIdStartLimit + 4) + +DEFINE_EVENT(evNPSetNotfnPersistentType, kCuiEventIdStartLimit + 5) +DEFINE_EVENT(evNPSetDefaultPersistentData, kCuiEventIdStartLimit + 6) +DEFINE_EVENT(evNPReadPersistedData, kCuiEventIdStartLimit + 7) +DEFINE_EVENT(evNPReleaseLoadAck, kCuiEventIdStartLimit + 8) +DEFINE_EVENT(evNPNorShutdownAck, kCuiEventIdStartLimit + 9) +DEFINE_EVENT(evNPRegisterPersistentFile, kCuiEventIdStartLimit + 10) +DEFINE_EVENT(evNPReleasePersistentFile, kCuiEventIdStartLimit + 11) +DEFINE_EVENT(evNPLoadPersistentFile, kCuiEventIdStartLimit + 12) +DEFINE_EVENT(evNPSetFilePersistentType, kCuiEventIdStartLimit + 13) +DEFINE_EVENT(evNPSetFolderPersistentType, kCuiEventIdStartLimit + 14) +DEFINE_EVENT(evUserChange, kCuiEventIdStartLimit + 15) +DEFINE_EVENT(evShutdownTimeout, kCuiEventIdStartLimit + 16) + +DEFINE_EVENT(evNPPublishNotification, kCuiEventIdStartLimit + 17) +DEFINE_EVENT(evNPRegisterNotifications, kCuiEventIdStartLimit + 18) +DEFINE_EVENT(evNPSubscribeToNotification, kCuiEventIdStartLimit + 19) +DEFINE_EVENT(evNPSubscribeToNotifications, kCuiEventIdStartLimit + 20) +DEFINE_EVENT(evNPUnRegisterNotifications, kCuiEventIdStartLimit + 21) +DEFINE_EVENT(evNPUnSubscribeFromNotification, kCuiEventIdStartLimit + 22) +DEFINE_EVENT(evNPRegisterPersistentFolder, kCuiEventIdStartLimit + 23) +DEFINE_EVENT(evNPLoadPersistentFolder, kCuiEventIdStartLimit + 24) +DEFINE_EVENT(evNPReleasePersistentFolder, kCuiEventIdStartLimit + 25) +DEFINE_EVENT(evNPUnSubscribeFromNotifications, kCuiEventIdStartLimit + 26) +DEFINE_EVENT(evCheckAllFilesPersisted, kCuiEventIdStartLimit + 27) +DEFINE_EVENT(evNPGetReadyStatus, kCuiEventIdStartLimit + 28) +DEFINE_EVENT(evNPRegisterImmediateNotifications, kCuiEventIdStartLimit + 29) +DEFINE_EVENT(evNPClearPersistedData, kCuiEventIdStartLimit + 30) + +DEFINE_EVENT(evNPShutdownDataSave, kCuiEventIdStartLimit + 31) + +#ifdef NPP_PROFILEINFO_ENABLE + +DEFINE_EVENT(evNPProfileNotification, kCuiEventIdStartLimit + 32) +DEFINE_EVENT(evNPProfilePersistence, kCuiEventIdStartLimit + 33) + +#endif + +DEFINE_EVENT(evNPPublishImmediateNotification, kCuiEventIdStartLimit + 34) +DEFINE_EVENT(evNPPersistentSync, kCuiEventIdStartLimit + 35) + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// SetPersonality +/// Set the personality in the framework on userchange. +/// +/// \param [IN] f_happ +/// HANDLE - Application Handle +/// +/// \param [IN] f_tMsg +/// NC_User - Structure containing user specific details +/// +/// \return EFrameworkunifiedStatus +// EFrameworkunifiedStatus - success or failure status +/// +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus SetPersonality(HANDLE f_happ, NC_User &f_tMsg); // NOLINT (runtime/references) + + +/* + * CShutDownMsgData + * This class is used to pass the data between states sShutdownIdle and sShutdownDataSave + */ +class CShutDownMsgData : public CEventData { + public: + // constructor + CShutDownMsgData(UI_32 f_uieventid, EFrameworkunifiedShutdownType f_etype, UI_32 f_uidata): CEventData(f_uieventid), + m_eShutdownType(f_etype), m_uiMsgData(f_uidata) {} // LCOV_EXCL_BR_LINE 11: unexpected branch + + // destructor + virtual ~CShutDownMsgData() {} + + EFrameworkunifiedShutdownType m_eShutdownType; + + UI_32 m_uiMsgData; +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_APP_STATES_H_ diff --git a/nsframework/notification_persistent_service/server/include/native_service/notification_persistent_service.h b/nsframework/notification_persistent_service/server/include/native_service/notification_persistent_service.h new file mode 100644 index 00000000..a7c9f8ec --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/native_service/notification_persistent_service.h @@ -0,0 +1,40 @@ +/* + * @copyright Copyright (c) 2017-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. + */ +/** + * @file notification_persistent_service.h + * @brief \~english include all notification_persistent_service head files + */ + +/** @addtogroup BaseSystem + * @{ + */ +/** @addtogroup native_service + * @ingroup BaseSystem + * @{ + */ +/** @addtogroup notification_persistent_service + * @ingroup native_service + * @{ + */ + +#ifndef NATIVESERVICE_NOTIFICATIONPERSISTENTSERVICE_H_ // NOLINT(build/header_guard) +#define NATIVESERVICE_NOTIFICATIONPERSISTENTSERVICE_H_ + +#endif // NATIVESERVICE_NOTIFICATIONPERSISTENTSERVICE_H_ + +/** @}*/ // end of notification_persistent_service +/** @}*/ // end of native_service +/** @}*/ // end of BaseSystem diff --git a/nsframework/notification_persistent_service/server/include/ns_npp.h b/nsframework/notification_persistent_service/server/include/ns_npp.h new file mode 100644 index 00000000..f96dd755 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp.h @@ -0,0 +1,296 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief +/// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_H_ + +#include <native_service/frameworkunified_sm_framework_types.h> +#include <native_service/frameworkunified_sm_hsm.h> +#include <native_service/frameworkunified_types.h> +#include <string> + + +class CPersistenceManager; +class CNotificationManager; +class CnotificationpersistentservicePersonalizationManager; + +/** + * This class act as a controller class which holds the instance of notification, personalization + * and persistence manager respectively. + */ +class CNSNPP: public CFrameworkunifiedHSM { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CNSNPP + /// Constructor of CNSNPP class + /// + /// \param f_happ + /// PVOID - application handle + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + explicit CNSNPP(PVOID f_happ); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CNSNPP + /// Destructor of CNSNPP class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CNSNPP(); + + /////////////////////////////////////////////////////////////////////////////////////////// + /// Init + /// This function is used to allocate dynamic memory for member variables of this class after + /// creation of object. + /// + /// \param f_happ + /// HANDLE - Application handle + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - Returns status of operation + /// + /////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus Init(HANDLE f_happ); + + /////////////////////////////////////////////////////////////////////////////////////////// + /// DeInit + /// This function is used to deinitialize the NPP object. + /// + /// \param f_happ + /// HANDLE - Application handle + /// + /// \return VOID + /// VOID - Returns status of operation + /// + /////////////////////////////////////////////////////////////////////////////////////////// + VOID DeInit(HANDLE f_happ); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// FrameworkunifiedCreate + /// This function is pure virtual function of parent class. + /// In this function, states and events of StateMachine are created and connected. + /// + /// \param [in] f_peventdata + /// PVOID - Event data + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - Returns status of operation + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus FrameworkunifiedCreate(PVOID f_peventdata = NULL); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentservicePersistAll + /// Persist all persistent state, user persistent state notification data; + /// and all global and user related files to permenant storage + /// + /// \param [in] f_eshutdowntype + /// EFrameworkunifiedShutdownType - shutdown type i.e. normal shutdown, quick, data reset + /// + /// \param [in] f_uinotificationpersistentservicepersistcategoryflag + /// UI_32 - Hex value from enum EFrameworkunifiedPersistCategory, representing data to persist + /// 0 - persist orignal data and + /// 1 - persist default data + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - Returns status of operation + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentservicePersistAll(EFrameworkunifiedShutdownType f_eshutdowntype, UI_32 f_uinotificationpersistentservicepersistcategoryflag); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceSaveNotificationPersistentData + /// In this function, all the data related to persistent notification is retrieved from + /// notification manager and stored in persistent file by persistent manager. + /// + /// \param [in] f_epersistenttype + /// EFrameworkunifiedPersistentVarType - Type of persistent notification + /// \param [in] f_uinotificationpersistentservicepersistcategoryflag + /// UI_32 - Hex value from enum EFrameworkunifiedPersistCategory, representing data to persist + /// 0 - persist orignal data and + /// 1 - persist default data + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - Returns status of operation + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceSaveNotificationPersistentData(EFrameworkunifiedNotificationType f_epersistenttype, + UI_32 f_uinotificationpersistentservicepersistcategoryflag = 0x0); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceLoadPersistentNotificationData + /// In this transition, persistent file is loaded by persistent manager and + /// persistent notifications and its data is loaded to notification manager. + /// + /// \param [in] f_epersistenttype + /// EFrameworkunifiedPersistentVarType - Type of persistent notification + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - Returns status of operation + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceLoadPersistentNotificationData(EFrameworkunifiedNotificationType f_epersistenttype); + + /////////////////////////////////////////////////////////////////////////////////////////// + /// DeletePersistedDataFolder + /// This function does not deletes the data instead just rename the folder which needs to + /// be deleted. And this data will gets deleted during next startup. + /// + /// \param f_uipersistcategoryflag + /// UI_32 - Rename the persisted data folder depending on enum EFrameworkunifiedPersistCategory value + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - Returns status of operation + /// + /////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus DeletePersistedDataFolder(UI_32 f_uipersistcategoryflag); + + /////////////////////////////////////////////////////////////////////////////////////////// + /// Syncfs + /// Syncfs is carried out. + /// + /// \param + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - Returns status of operation + /// + /////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus Syncfs(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Singleton instance of NotificationManager + //////////////////////////////////////////////////////////////////////////////////////////////// + CNotificationManager *m_pNotificationManager; ///< Instance of Notification Manager + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Singleton instance of PersonalizationManager + //////////////////////////////////////////////////////////////////////////////////////////////// + CnotificationpersistentservicePersonalizationManager *m_pPersonalizationManager; ///< Instance of Personalization Manager + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Singleton instance of PersistenceManager + //////////////////////////////////////////////////////////////////////////////////////////////// + CPersistenceManager *m_pPersistenceManager; + // scheduling priority of read thread + static SI_32 m_siReadThreadPrio; // NOLINT (readability/naming) + // scheduling priority of write thread + static SI_32 m_siWriteThreadPrio; // NOLINT (readability/naming) + // scheduling priority of immediate persistence thread + static SI_32 m_siImmediatePersistenceThreadPrio; // NOLINT (readability/naming) + // number of times CRC check is required. (CRC check will be done more than once only on failure) + static UI_16 + m_siCRCCheckCount; // NOLINT (readability/naming) + + private: + ///< name of reader thread + const std::string m_cReadThreadName; // NOLINT (readability/naming) + ///< name of writer thread + const std::string m_cWriteThreadName; // NOLINT (readability/naming) + ///< name of immediate persistence thread + const std::string m_cImmediatePersistenceThreadName; // NOLINT (readability/naming) + + /////////////////////////////////////////////////////////////////////////////////////////// + /// CreateAndStartChildThreads + /// This function creates and start all child threads. + /// + /// \param f_happ + /// HANDLE - Application handle + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - Returns status of operation + /// + /////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus CreateAndStartChildThreads(HANDLE f_happ); + + /////////////////////////////////////////////////////////////////////////////////////////// + /// SwitchToFileStructureVersion1 + /// Copy all the data from old persistent path to new persistent path + /// + /// \param [IN] f_uinppversion + /// UI_32 - New version of NPPService + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - Returns status of operation + /// + /////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus SwitchToFileStructureVersion1(const UI_32 f_uinppversion); + + /////////////////////////////////////////////////////////////////////////////////////////// + /// SwitchToFileStructureVersion2 + /// Move immediate notification data files from IMMEDIATE_PERSISTENCE_STORAGE_V1 to + /// IMMEDIATE_PERSISTENCE_STORAGE_V2/AllUserAppData/UserData + /// + /// \param [IN] f_uinppversion + /// UI_32 - New version of NPPService + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - Returns status of operation + /// + /////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus SwitchToFileStructureVersion2(const UI_32 f_uinppversion); + + /////////////////////////////////////////////////////////////////////////////////////////// + /// GetNSNPPVersion + /// Get the version of NSNPP from version.txt + /// + /// \param + /// + /// \return UI_8 + /// UI_8 - version number + /// + /////////////////////////////////////////////////////////////////////////////////////////// + UI_32 GetNSNPPVersion(); + + /////////////////////////////////////////////////////////////////////////////////////////// + /// SetNSNPPVersion + /// Set the version of NSNPP in version.txt + /// + /// \param [IN] f_uiversion + /// UI_32 - version number + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - Returns status of operation + /// + /////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus SetNSNPPVersion(UI_8 f_uiversion); + + HANDLE m_hNSReadThread; ///< Reader thread handle + + HANDLE m_hNSWriteThread; ///< Writer thread handle + + HANDLE m_hNSImmediatePersistenceThread; ///< immediate persistence thread handle +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_binary_accesser.h b/nsframework/notification_persistent_service/server/include/ns_npp_binary_accesser.h new file mode 100644 index 00000000..aed4d2a8 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_binary_accesser.h @@ -0,0 +1,230 @@ +/* + * @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 CBinaryAccesser class. +/// This class stores data in a file in binary format. +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_BINARY_ACCESSER_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_BINARY_ACCESSER_H_ + +#include <native_service/frameworkunified_types.h> +#include <string> +#include <vector> +#include "ns_npp_persistent_accesser.h" + +class CPersistentAccesser; +class CPersistentData; +class CNotificationsToPersist; +class CPersistDataHeader; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// vector of all available persistent notification and its data. +//////////////////////////////////////////////////////////////////////////////////////////////////// +typedef std::vector<CNotificationsToPersist *> Persistent_Notification_List_Type; + +typedef Persistent_Notification_List_Type::iterator Persistent_Notification_List_Iterator; + +/** + * This class stores data in a file in binary format. + * + */ +class CBinaryAccesser: public CPersistentAccesser { + public: + typedef enum FileOpentype { + EREAD = 0, + EWRITE + } FILE_OPEN_TYPE; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CBinaryAccesser + /// Constructor of CBinaryAccesser class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CBinaryAccesser(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CBinaryAccesser + /// Destructor of CBinaryAccesser class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CBinaryAccesser(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// PersistData + /// Persist data in persistent memory in a file in binary format. + /// + /// \param [IN] f_cmemfilepath + /// std::string - Memory file path for saving notification. + /// + /// \param [IN] f_vdata + /// Persistent_Notification_List_Type* - Data which has to be persisted. + /// + /// \param [IN] f_epersistenttype + /// EFrameworkunifiedNotificationType - Type of Notification. + /// + /// \param [IN] f_epersistcategory + /// EFrameworkunifiedPersistCategory - persist category + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus PersistData(std::string f_cmemfilepath, + Persistent_Notification_List_Type *f_vdata, + EFrameworkunifiedNotificationType f_epersistenttype, + EFrameworkunifiedPersistCategory f_epersistcategory = eFrameworkunifiedUserData); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// RetrieveData + /// Retrieve data from from a file from persistent memory and store in a vector. + /// + /// \param [IN] f_cmemfilepath + /// std::string - Memory file path from where to retrieve notification data. + /// + /// \param [OUT] f_vdata + /// Persistent_Notification_List_Type*& - Retrieved notification data is filled in this vector. + /// + /// \param [IN] f_epersistcategory + /// EFrameworkunifiedPersistCategory - persist category + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus RetrieveData(std::string f_cmemfilepath, + Persistent_Notification_List_Type *&f_vdata, // NOLINT (runtime/references) + EFrameworkunifiedPersistCategory f_epersistcategory = eFrameworkunifiedUserData); + + private: + UI_32 m_uiCurStrOffset; + UI_32 m_uiCurStrSize; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// OpenFileForReading + /// Open file in read mode. + /// + /// \param [OUT] f_Fd + /// int * - File descriptor to read from a file + /// + /// \param [IN] f_cfilepath + /// std::string - File Path from the file is to be read + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus OpenFileForReading(int *f_infd, + std::string f_cfilepath); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// OpenFileForWriting + /// Open file in write mode. + /// + /// \param [OUT] f_Fd + /// int * - File descriptor to write to a file + /// + /// \param [IN] f_cfilepath + /// std::string - File Path for the file that is to be written + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus OpenFileForWriting(int *f_outfd, + std::string f_cfilepath); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// WriteHeaderAndData + /// Write header and data in a file. + /// + /// \param [IN] f_pnotificationstopersist + /// CNotificationsToPersist - Object of class CNotificationsToPersist + /// + /// \param [IN] f_pdata + /// PVOID - notification data + /// + /// \param [IN] f_Fd + /// int - File descriptor to write the file. + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus WriteHeaderAndData(CNotificationsToPersist *f_pnotificationstopersist, + PVOID f_pdata, + int f_outfd); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ReadHeaderAndData + /// Read header from the file. + /// + /// \param [IN] f_objcpersistdataheader + /// CPersistDataHeader& - Object of class CPersistDataHeader + /// + /// \param [OUT] f_pdata + /// CHAR*& - + /// + /// \param [IN] f_Fd + /// int - File descriptor to read the file. + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus ReadHeaderAndData(CPersistDataHeader &f_objcpersistdataheader, // NOLINT (runtime/references) + CHAR *&f_pdata, int f_infd); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// FillNotificationList + /// This function retrieves the notification data from file and fill it in map. + /// + /// \param [IN] f_Fd + /// int - File descriptor to retrieve notification data. + /// + /// \param [OUT] f_vdata + /// Persistent_Notification_List_Type*& - Retrieved notification data is filled in this vector. + /// + /// \param [IN] f_epersistcategory + /// EFrameworkunifiedPersistCategory - persist category + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus FillNotificationList(int f_infd, + Persistent_Notification_List_Type *&f_vdata, // NOLINT (runtime/references) + EFrameworkunifiedPersistCategory f_epersistcategory); + + EFrameworkunifiedStatus WriteFileHeaderAndDuplicate(int f_outfd, std::string f_cfilepath); + EFrameworkunifiedStatus CheckFileHeader(int f_infd); + EFrameworkunifiedStatus OpenBakFileForReading(int *f_infd, std::string f_cfilepath); + UI_32 CalcCRC(PVOID f_pdata, UI_32 f_size); +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_BINARY_ACCESSER_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_copy_worker.h b/nsframework/notification_persistent_service/server/include/ns_npp_copy_worker.h new file mode 100644 index 00000000..984296f6 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_copy_worker.h @@ -0,0 +1,558 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contain declaration of class CCopyWorker and CArchive. +/// Class CCopyWorker holds the implementation for worker thread. +/// Class CArchive holds the implementation for archive. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_COPY_WORKER_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_COPY_WORKER_H_ + +#define LIBTARFAIL -1 +#define LIBTARSUCCESS 0 +#define TARMODE 0644 +#define FILEERROR -1 + +#include <pthread.h> +#include <libtar.h> +#include <stdio.h> +#include <zlib.h> + +#include <native_service/frameworkunified_framework_if.h> +#include <native_service/ns_utility_sys.hpp> +#include <native_service/frameworkunified_multithreading.h> +#include <native_service/ns_np_service.h> + +#include <map> +#include <string> + +#include "ns_npp_types.h" + +typedef std::map<std::string, UI_32> TMTagCRC; // map of tag and corresponding CRC +typedef std::map<std::string, TMTagCRC> TMServiceTagCRC; // map of service and tag list +typedef std::map<int, gzFile> GZFiles; + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NSPCopyWorkerOnStart +/// Callback method on start of worker thread. +/// +/// \param [IN] f_hthread +/// HANDLE - Thread Handle +/// +/// \return EFrameworkunifiedStatus +// EFrameworkunifiedStatus - success or failure status +/// +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NSPCopyWorkerOnStart(HANDLE f_hthread); + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NSPCopyWorkerOnStop +/// Callback method on stopping of worker thread. +/// +/// \param [IN] f_hthread +/// HANDLE - Thread Handle +/// +/// \return EFrameworkunifiedStatus +// EFrameworkunifiedStatus - success or failure status +/// +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NSPCopyWorkerOnStop(HANDLE f_hthread); + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// gzopen_frontend +/// Method to set archiving options. +/// +/// \param [IN] f_pcpathname +/// PCHAR - Thread Handle +/// +/// \param [IN] f_sioflags +/// SI_32 - Open file flags +/// +/// \param [IN] f_simode +/// SI_32 - File Mode +/// +/// \return EFrameworkunifiedStatus +// EFrameworkunifiedStatus - success or failure status +/// +//////////////////////////////////////////////////////////////////////////////////////////////// +SI_32 OpenArchive(PCHAR f_pcpathname, SI_32 f_sioflags, SI_32 f_simode); + +int CloseArchive(int fd); +ssize_t ReadArchive(int fd, void *buf, size_t count); +ssize_t WriteArchive(int fd, const void *buf, size_t count); + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPServiceOnDeleteOldDataCmd +/// This callback is used to delete the data which was requested to be deleted during +/// previous shutdown. +/// +/// \param [in] f_happ +/// HANDLE - Handle to notificationpersistentservice_application Framework. +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPServiceOnDeleteOldDataCmd(HANDLE f_happ); + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NSPDataResetThreadCallback +/// Callback of data reset thread. +/// This callback delete all the data which was requested for reset during previous shutdown. +/// +/// \param [in] f_parg +/// PVOID - Thread argument +/// +/// \return PVOID +/// PVOID - NULL +//////////////////////////////////////////////////////////////////////////////////////////// +PVOID NSPDataResetThreadCallback(PVOID f_parg); + +class CCopyWorker { + public: + static TMServiceTagCRC g_mservicetagcrc; + static CMutex g_objmtxservicetag; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CCopyWorker + /// Constructor of class CCopyWorker + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CCopyWorker(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CCopyWorker + /// Destructor of class CCopyWorker + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CCopyWorker(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// OnWrkCmdCopy + /// Callback method for start copy command. + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus OnWrkCmdCopy(HANDLE hthread); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// OnWrkCmdResume + /// Callback method for resuming worker thread. + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus OnWrkCmdResume(HANDLE hthread); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// OnWrkCmdStart + /// Callback method for starting worker thread. + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus OnWrkCmdStart(HANDLE hthread); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// OnWrkCmdArchive + /// Callback method to start archiving/unarchiving for file or folder + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus OnWrkCmdArchive(HANDLE f_hthread); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// OnWrkCmdStop + /// Callback method for stopping worker thread. + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus OnWrkCmdStop(HANDLE hthread); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// OnCmdShutdownRequest + /// Callback method on shutdown request. + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus OnCmdShutdownRequest(HANDLE hthread); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Abort + /// Method to abort worker thread tasks. + /// + /// + /// \return VOID + // + //////////////////////////////////////////////////////////////////////////////////////////////// + static VOID Abort(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetCopyStatusToFailure + /// Method to set the copy status to failure. + /// + /// \param [IN] f_tcopystatusresponse + /// NSP_CopyStatusResponse - Response status struct + /// + /// \param [IN] f_eworkerfailcmd + /// ENPS_CopyWorkerFailures - Worker failure Commands + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus SetCopyStatusToFailure(NSP_CopyStatusResponse &f_tcopystatusresponse, // NOLINT (runtime/references) + const ENPS_CopyWorkerFailures f_eworkerfailcmd); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// InAbortState + /// Method to check if the thread is in abort state + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \return BOOL + // BOOL - true if in abort state or false. + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + BOOL InAbortState() const; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SendAck + /// Method to send ack to the parent thread + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \param [IN] f_eworkercmd + /// ENSP_CopyWorkerProtocol - Worker protocol command + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus SendAck(HANDLE hthread, const ENSP_CopyWorkerProtocol &f_eworkercmd); + + private: + static pthread_mutex_t m_sAbortMutex; // NOLINT (readability/naming) , Mutex for abort + static BOOL m_sbAbortCopy; // NOLINT (readability/naming) , Check for abort state + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CopyFile + /// Copy the content of source file f_csrcpath to destination file f_cdestpath. + /// Creates the destination file path if does not exists. + /// + /// \param [IN] f_csrcpath + /// PCSTR - source file path + /// + /// \param [IN] f_cdestpath + /// PCSTR - dest file path + /// + /// \param [OUT] f_uiwritesize + /// UI_32 - number of bytes written to the destination file + /// + /// \param [IN] f_btmpfile + /// BOOL - TRUE:RELEASE-temp file use /FALSE:LOAD-temp file not use + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - eFrameworkunifiedStatusOK on success else eFrameworkunifiedStatusFail + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus CopyFile(PCSTR f_csrcpath, PCSTR f_cdestpath, UI_32 &f_uiwritesize, BOOL btmpfile = FALSE); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetCopyBufSize + /// Get the buffer size appropriate for file copy + /// + /// \param [IN] f_si32openfd + /// SI_32 - File descriptor of a file opened with open() api + /// + /// \param [OUT] f_ui32filesize + /// UI_32 - Get the size of file + /// + /// \return SI_32 + /// SI_32 - Returns the buffer size appropriate for file copy + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + SI_32 GetCopyBufSize(SI_32 f_si32openfd, UI_32 &f_ui32filesize); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// VerifyWithStoredCRC + /// Verify CRC stored internally for the tag matches with the CRC of a file (file passed as a argument) + /// + /// \param [IN] f_crequesterappname + /// PCSTR - Name of the requester. This is to find the corresponding stored CRC + /// + /// \param [IN] f_cpersistenttag + /// PCSTR - Tag. This is to find the corresponding stored CRC + /// + /// \param [IN] f_cFile + /// PCSTR - Complete file path on temporary storage. + /// Comparison of CRC needs to be done with this temporary file. + /// + /// \return BOOL + /// BOOL - Returns TRUE if f_cFile's CRC matches with CRC stored internally for the corresponding tag + /// else FALSE + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + BOOL VerifyWithStoredCRC(PCSTR f_crequesterappname, PCSTR f_cpersistenttag, PCSTR f_cFile, UI_32 &f_ui32crc); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// UpdateTagCRC + /// Update the passed CRC in the internal map for the corresponding requester and tag. + /// + /// \param [IN] f_crequesterappname + /// PCSTR - Name of the requester. + /// + /// \param [IN] f_cpersistenttag + /// PCSTR - File Tag. + /// + /// \param [IN] f_ui32crc + /// UI_32 - New CRC. + /// + /// \return None + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + VOID UpdateTagCRC(PCSTR f_crequesterappname, PCSTR f_cpersistenttag, UI_32 f_ui32crc); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// TryFileCopyWithCRCCheck + /// Try to copy file from source to destination until src and dest CRC matches or max f_ui32checkcount + /// number of times + /// + /// \param [IN] f_csource + /// PCSTR - Source file + /// + /// \param [IN] f_cdest + /// PCSTR - Destination file + /// + /// \param [IN] f_ui32checkcount + /// UI_32 - Maximum number of times to perform file copy + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - eFrameworkunifiedStatusOK - If file copy done successfully and CRC matches. + /// eFrameworkunifiedStatusFail - otherwise + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus TryFileCopyWithCRCCheck(PCSTR f_csource, PCSTR f_cdest, UI_32 f_ui32checkcount); + + class CArchive { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CArchive + /// Constructor of CArchive class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CArchive(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CArchive + /// Destructor of CArchive class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual ~CArchive(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Archive + /// Method for performing folder archive or extraction operation. + /// + /// \param [IN] f_tarchiveinfocmd + /// NSP_CopyInfoCmd - Archive Command Info Structure + /// + /// \param [IN] f_tarchivestatusresponse + /// NSP_CopyStatusResponse - Archive Command Response Structure + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus Archive(NSP_CopyInfoCmd &f_tarchiveinfocmd, NSP_CopyStatusResponse &f_tarchivestatusresponse); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// FileOperationUsingLibz + /// Method to determine whether to compress or decompres file using libz. + /// + /// \param [IN] f_toperainfocmd + /// NSP_CopyInfoCmd - File Operation Command Info Structure + /// + /// \param [IN] f_toperarespstatus + /// NSP_CopyStatusResponse - File Operation Command Response Structure + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus FileOperationUsingLibz(NSP_CopyInfoCmd &f_toperainfocmd, NSP_CopyStatusResponse &f_toperarespstatus); // NOLINT (runtime/references) + + private: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CreateTar + /// Method to Create tar archive. + /// + /// \param [IN] f_csourepath + /// std::string - Source path of the folder to be archived + /// + /// \param [IN] f_cdestpath + /// std::string - Destination path for the archived folder. + /// + /// \param [IN] f_tarchivestatusresponse + /// NSP_CopyStatusResponse - Archive Command Response Structure + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus CreateTar(const std::string &f_csourepath, const std::string &f_cdestpath, + NSP_CopyStatusResponse &f_tarchivestatusresponse); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ExtractTar + /// Method to extract tar archive. + /// + /// \param [IN] f_csourepath + /// std::string - Source path of the folder to be extracted + /// + /// \param [IN] f_csourcedest + /// std::string - Destination path for the extracted folder. + /// + /// \param [IN] f_tarchivestatusresponse + /// NSP_CopyStatusResponse - Archive Command Response Structure + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus ExtractTar(const std::string &f_csourepath, const std::string &f_csourcedest, + NSP_CopyStatusResponse &f_tarchivestatusresponse); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Create + /// Method to Create archive + /// + /// \param [IN] f_pctarfiledestpath + /// CHAR - Destination path for the archived folder. + /// + /// \param [IN] f_pcrootdirpath + /// CHAR - Source path of the folder to be archived + /// + /// \param [IN] f_plibtarlist + /// BOOL - TRUE if user file else FALSE + /// + /// \return SI_32 + // + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus Create(std::string &f_pctarfiledestpath, std::string &f_pcrootdirpath, libtar_list_t *f_plibtarlist); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Extract + /// Nethod to extract archive. + /// + /// \param [IN] f_pcrootdirpath + /// CHAR - Source path of the folder to be extracted + /// + /// \param [IN] f_pctarfiledestpath + /// CHAR - Destination path for extraction. + /// + /// \return SI_32 + // + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus Extract(std::string &f_pcrootdirpath, std::string &f_pctarfiledestpath); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CompressUsingZlib + /// Method to compress file using libz + /// + /// \param [IN] f_csourepath + /// std::string - Source path of the file to be compressed + /// + /// \param [IN] f_cdestpath + /// std::string - Destination path for the compressed file. + /// + /// \param [IN] f_iziplevel + /// Level of compression i.e. + /// More compression results in more time taken for compression operation and vice versa. + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus CompressUsingZlib(const std::string &f_csourepath, const std::string &f_cdestpath, SI_32 f_iziplevel); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// DeCompressUsingZlib + /// Method to decompress file using libz. + /// + /// \param [IN] f_csourepath + /// std::string - Source path of the file to be decompressed. + /// + /// \param [IN] f_csourcedest + /// std::string - Destination path for the decompressed file. + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus DeCompressUsingZlib(const std::string &f_csourepath, const std::string &f_csourcedest); + }; +}; +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_COPY_WORKER_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_fs_directory.h b/nsframework/notification_persistent_service/server/include/ns_npp_fs_directory.h new file mode 100644 index 00000000..4f7876db --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_fs_directory.h @@ -0,0 +1,111 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains declaration of class CFSDirectory. +/// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_FS_DIRECTORY_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_FS_DIRECTORY_H_ +#include <native_service/frameworkunified_types.h> +#include <string> + + + +// Class to provide file system directory operations like create,delete etc. +class CFSDirectory { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CFSDirectory + /// Constructor of CFSDirectory class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CFSDirectory(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CFSDirectory + /// Destructor of CFSDirectory class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CFSDirectory(); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// This method is used to check if the directory exists. + /// + /// \param [in] f_cdirpath + /// std::string - Path of the directory to delete. + /// + /// \return status + /// EFrameworkunifiedStatus - success or error + //////////////////////////////////////////////////////////////////////////////////////////// + static BOOL DoesDirecotryExist(const std::string &f_cdirpath); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// This method is used to create a directory. + /// + /// \param [in] f_cdirpath + /// std::string - Path of the directory to delete. + /// + /// \return status + /// EFrameworkunifiedStatus - success or error + //////////////////////////////////////////////////////////////////////////////////////////// + static EFrameworkunifiedStatus CreateDirectory(const std::string &f_cdirpath); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// This method is used to verify directory. + /// + /// \param [in] f_cpath + /// std::string - Path of the directory to delete. + /// + /// \return status + /// EFrameworkunifiedStatus - success or error + //////////////////////////////////////////////////////////////////////////////////////////// + static BOOL IsDirectory(const std::string &f_cpath); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// This method is used to delete directory with delay of f_uidelay(msec) + /// between consecutive deletes. + /// + /// \param [in] f_cpath + /// std::string - Path of the directory to delete. + /// \param [in] f_uidelay + /// UI_32 - delay in millisec before recursive call. + /// + /// \return status + /// EFrameworkunifiedStatus - success or error + //////////////////////////////////////////////////////////////////////////////////////////// + static BOOL RemoveDirectory(std::string f_cpath, const UI_32 f_uidelay = 0); +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_FS_DIRECTORY_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_handlelist.h b/nsframework/notification_persistent_service/server/include/ns_npp_handlelist.h new file mode 100644 index 00000000..30c8a26f --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_handlelist.h @@ -0,0 +1,145 @@ +/* + * @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. +////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_HANDLELIST_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_HANDLELIST_H_ + +#include <native_service/frameworkunified_types.h> +#include <string> +#include <map> +#include <utility> + +typedef std::map<std::string, HANDLE> HandleList_Type; +typedef std::pair<HandleList_Type::iterator, bool> HandleListRetStatus_Type; + + + +/** + * This class holds the message queue handles for notification subscribers + */ +class CHandleList { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetHandleList + /// This function is used to get the singleton instance of class. + /// NOTE: Not thread safe. Others threads would not use this function. + /// + /// \return CHandleList + /// CHandleList - singleton instance of class + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + static CHandleList *GetHandleList(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ReleaseHandleList + /// This function is used to release the instance of class. + /// NOTE: Not thread safe. Others threads would not use this function. + /// + /// \param + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + static EFrameworkunifiedStatus ReleaseHandleList(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// AddHandleInList + /// Add pair of subscriber name and corresponding handle in map. + /// NOTE: Not thread safe. Others threads would not use this function. + /// + /// \param [IN] f_csubscribername + /// std::string - name of application subscribing for notification + /// \param [IN] f_hmqhandle + /// HANDLE - Message queue handle of the subscriber + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus AddHandleInList(std::string f_csubscribername, HANDLE f_hmqhandle); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// RemoveHandleFromList + /// Remove handle for subscriber from the list. + /// Handle will actually get removed when all the notifications are unsubscribed by the subscriber + /// NOTE: Not thread safe. Others threads would not use this function. + /// + /// \param [IN] f_csubscribername + /// std::string - name of application subscribing for notification + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus RemoveHandleFromList(std::string f_csubscribername); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetSubscriberMqHandle + /// Get the message queue handle of a subscriber. + /// NOTE: Not thread safe. Others threads would not use this function. + /// + /// \param [IN] f_csubscribername + /// std::string - name of application subscribing for notification + /// + /// \return HANDLE + // HANDLE - Message queue handle of the subscriber + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + HANDLE GetSubscriberMqHandle(std::string f_csubscribername); + + private: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CHandleList + /// Constructor of CHandleList class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CHandleList(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CHandleList + /// Destructor of CHandleList class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CHandleList(); + + HandleList_Type m_mHandleList; ///< map which stores all the message queue handle + + static CHandleList *m_psHandleList; // NOLINT (readability/naming) +}; +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_HANDLELIST_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_nor_persistence_worker_thread.h b/nsframework/notification_persistent_service/server/include/ns_npp_nor_persistence_worker_thread.h new file mode 100644 index 00000000..a3994ca0 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_nor_persistence_worker_thread.h @@ -0,0 +1,218 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contain declaration of class CImmediatePersistenceWorker and holds the +/// implementation for worker thread. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOR_PERSISTENCE_WORKER_THREAD_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOR_PERSISTENCE_WORKER_THREAD_H_ + +#include <native_service/frameworkunified_types.h> +#include <native_service/ns_timer_if.hpp> + +#include "ns_npp_types.h" + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NSP_NorPersistenceWorkerOnStart +/// Callback method on start of worker thread. +/// +/// \param [IN] hthread +/// HANDLE - Thread Handle +/// +/// \return EFrameworkunifiedStatus +// EFrameworkunifiedStatus - success or failure status +/// +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NSPNorPersistenceWorkerOnStart(HANDLE hthread); + +//////////////////////////////////////////////////////////////////////////////////////////////// +/// NSPNorPersistenceWorkerOnStop +/// Callback method on stopping of worker thread. +/// +/// \param [IN] hthread +/// HANDLE - Thread Handle +/// +/// \return EFrameworkunifiedStatus +// EFrameworkunifiedStatus - success or failure status +/// +//////////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NSPNorPersistenceWorkerOnStop(HANDLE hthread); + +// Forward Declaration for class +class CNotificationsToPersist; + + +/** + * This class handles the immediate persistence notification related requests. + * + */ +class CNorPersistenceWorker { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CNorPersistenceWorker + /// Constructor of class CNorPersistenceWorker + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CNorPersistenceWorker(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CNorPersistenceWorker + /// Destructor of class CNorPersistenceWorker + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CNorPersistenceWorker(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// OnNorPersistenceTimerStart + /// When immediate persistence notification publish request is received by NPPService. It sends a + /// NOR_PERSISTENCE_TIMER_START command to the worker thread and this function gets called. + /// This function starts the respective timer of the notification. Timeout of timer writes + /// corresponding notification data to persistent memory. + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus OnNorPersistenceTimerStart(HANDLE hthread); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// RegisterImmediatePersistNotification + /// When immediate persistence notification register request is received by NPPService. It sends a + /// NOR_PERSISTENCE_REGISTER command to the worker thread and this function gets called. + /// Registration with worker thread is required because only child thread will be responsible for + /// data saving related stuff. It creates a timer corresponding to the notification. + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus RegisterImmediatePersistNotification(HANDLE hthread); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// UnregisterImmediatePersistNotification + /// When immediate persistence notification unregister request is received by NPPService. It sends a + /// NOR_PERSISTENCE_UNREGISTER command to the worker thread and this function gets called. + /// It deletes a timer corresponding to the notification. + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus UnregisterImmediatePersistNotification(HANDLE hthread); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// OnShutdown + /// This API stops all the immediate notification timer. + /// This API immediately writes the data to persistent memory if the timer is runnning, + /// irrespective of delay unless the data . + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus OnShutdown(HANDLE hthread); + + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// OnCategoryChange + /// This API updates the category of immediate persistence notification. + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus OnCategoryChange(HANDLE hthread); +}; + +/** + * CTimerHelper class maps the timer id and corresponding data. + * + */ +class CTimerHelper: public NSTimer { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CTimerHelper + /// Constructor of class CTimerHelper + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CTimerHelper(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CTimerHelper + /// Destructor of class CTimerHelper + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CTimerHelper(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetCmdId + /// Returns the timer id of the timer. + /// + /// \param [IN] none + /// + /// \return UI_32 + // UI_32 - Timer id of the timer + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + UI_32 GetCmdId(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// OnTimeOut + /// This function gets called when timer expires. This function writes the notification data in + /// persistent memory. + /// + /// \param [IN] f_hthread + /// HANDLE - Thread Handle + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus OnTimeOut(HANDLE hthread); + + // member variables + PUI_8 m_pui8HeaderAndData; // header and corresponding data of the notfn stored as part of timer + + private: + UI_32 m_uiCmdId; // command id associated with timer +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOR_PERSISTENCE_WORKER_THREAD_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_notification.h b/nsframework/notification_persistent_service/server/include/ns_npp_notification.h new file mode 100644 index 00000000..673e54cd --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_notification.h @@ -0,0 +1,323 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains declaration of class CNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOTIFICATION_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOTIFICATION_H_ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <native_service/frameworkunified_types.h> +#include <map> +#include <string> +#include <iostream> +#include "ns_npp_notification_receiver.h" + +typedef std::map<std::string, CNotificationReceiver *> NotifReceiver_Type; + +/// Iterator of map of CNotificationReceiver +typedef NotifReceiver_Type::iterator NotifReceiver_Iterator_Type; + +/** + * This class is base class for all the notification types classes. + */ +class CNotification { + private: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CNotification + /// Parameterless Constructor of CNotification class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CNotification(); + + protected: + std::string m_cNotificationName; ///< Name of Notification + + UI_32 m_uiMaxMsgSize; ///< Maximum size of notification data + + EFrameworkunifiedNotificationType m_ePersistentType; ///< type of notification + + std::string m_cServiceName; ///< List of services registering notification + + NotifReceiver_Type *m_pmSubscribersList; ///< list of subscribers of notification + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// AddReceiverInMap + /// This function adds the name of the service to receiver list of notification. + /// + /// \param [IN] f_csubscribername + /// std::string - name of application subscribing for notification + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus AddReceiverInMap(const std::string &f_csubscribername); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// PublishData + /// This function publishes the notification to subscribed clients. + /// + /// \param [IN] f_hmsgqhandle + /// HANDLE - MessageQ Handle of ReceiverQ + /// + /// \param [IN] f_pmessage + /// std::string - data of notification + /// + /// \param [IN] f_uimsgsize + /// std::string - length of data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus PublishData(HANDLE f_hmsgqhandle, + const PVOID f_pmessage, + const UI_32 f_uimsgsize); + + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CNotification + /// Constructor of CNotification class + /// + /// \param [IN] f_cnotificationname + /// std::string - Notification name + /// + /// \param [IN] f_uimaxmsgsize + /// UI_32 - Maximum size of notification data + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CNotification(const std::string &f_cnotificationname, + const UI_32 f_uimaxmsgsize); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CNotification + /// Destructor of CNotification class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual ~CNotification(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// AddEventReciever + /// This function adds the name of the application to receiver list of particular notification. + /// + /// \param [IN] f_csubscribername + /// std::string - name of application subscribing for notification + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus AddEventReciever(const std::string &f_csubscribername); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Publish + /// This function publishes the notification to subscribed clients. + /// + /// \param [IN] f_cservicename + /// std::string - name of service publishing the notification + /// + /// \param [IN] f_pmessage + /// std::string - data of notification + /// + /// \param [IN] f_uimsgsize + /// std::string - length of data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus Publish(const std::string &f_cservicename, + PVOID f_pmessage, + const UI_32 f_uimsgsize); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// DeleteEventReciever + /// This function deletes the name of application from receivers list. + /// + /// \param [IN] f_csubscribername + /// std::string - name of application + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus DeleteEventReciever(const std::string &f_csubscribername); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetNewSubscribersList + /// This function sets the subscribers list of notification + /// + /// \param [IN] f_pnotification + /// CNotification - notification object containing subscribers list + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus SetNewSubscribersList(CNotification *f_pnotification); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetEventPublisher + /// This function set the publisher name to current received service name + /// + /// \param [IN] f_cservicename + /// std::string - name of application + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus SetEventPublisher(const std::string &f_cservicename); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ResetEventPublisher + /// This function resets the publisher name to NULL + /// + /// \param [IN] f_cservicename + /// std::string - name of application + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus ResetEventPublisher(const std::string &f_cservicename); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// IsServiceRegistered + /// This function checks whether the notification is registered with any service or not. + /// + /// \param + /// + /// \return BOOL + // BOOL - true,if subscriber list is empty + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + BOOL IsServiceRegistered(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// IsSubscribersListEmpty + /// This function is used to check whether any service is subscribed to notification + /// + /// \param + /// + /// \return BOOL + // BOOL - true,if subscriber list is empty + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + BOOL IsSubscribersListEmpty(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetNotificationName + /// This function is used to get the notification name. + /// + /// \param + /// + /// \return std::string + // std::string - notification name + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + std::string GetNotificationName(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetPublisherName + /// This function is used to get the publisher name of notification. + /// + /// \param + /// + /// \return std::string + // std::string - service name + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + std::string GetPublisherName(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetPersistenceType + /// This function is used to get the type of notification. + /// + /// \param + /// + /// \return EFrameworkunifiedPersistentVarType + // EFrameworkunifiedPersistentVarType - persistent type + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedNotificationType GetNotificationType(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetMaxMessageSize + /// This function is used to get the max size of data of notification message. + /// + /// \param + /// + /// \return UI_32 + // UI_32 - Max Message Size + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + UI_32 GetMaxMessageSize(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ResetMaxMessageSize + /// This function reset the max size of data that can be published with notification + /// + /// \param [IN] f_uilength + /// std::string - Max size for notification data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus ResetMaxMessageSize(const UI_32 f_uilength); + +#ifdef NPP_PROFILEINFO_ENABLE + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetSubscriberList + /// Returns the list of subscribers subscribed to notification + /// + /// \param + /// + /// \return NotifReceiver_Type + // NotifReceiver_Type - subscriber's list of notification + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + NotifReceiver_Type *GetSubscriberList(); + +#endif +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOTIFICATION_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_notification_manager.h b/nsframework/notification_persistent_service/server/include/ns_npp_notification_manager.h new file mode 100644 index 00000000..e730d02a --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_notification_manager.h @@ -0,0 +1,496 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains declaration of singleton class CNotificationManager which is used +/// to manage notification information. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOTIFICATION_MANAGER_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOTIFICATION_MANAGER_H_ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <native_service/frameworkunified_types.h> +#include <native_service/ns_np_service.h> + +#include <map> +#include <vector> +#include <string> +#include <iostream> + +/// forward declaration of class +class CNotification; +class CPersistentData; +class CNotificationsToPersist; +class CStateNotification; + +/// map of all the available notification. +typedef std::map<std::string, CNotification *> Notification_Type; + +/// iterator for map of notifications. +typedef Notification_Type::iterator Notification_Iterator_Type; + +/// map of all available persistent notification and its data. +typedef std::map<std::string, CPersistentData *> Persistent_Type; + +/// Iterator for map of persistent notifications. +typedef Persistent_Type::iterator Persistent_Iterator_Type; + +/** + * This class is used to manage the operations related to notification + * on registration, subscription, publication, etc. + */ +class CNotificationManager { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CNotificationManager + /// Constructor of CNotificationManager class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CNotificationManager(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CNotificationManager + /// Destructor of CNotificationManager class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CNotificationManager(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// 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. + /// + /// \param [IN] f_cservicename + /// std::string - name of service registering for notification + /// + /// \param [IN] f_cnotificationname + /// std::string - notification name + /// + /// \param [IN] f_uimsglength + /// UI_32 - Maximum length of Message + /// + /// \param [IN] f_enotificationtype + /// EFrameworkunifiedPersistentVarType - type of notification + /// + /// \param [IN] f_uidelay + /// UI_32 - Delay time for persistence + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus 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 = 0); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceServiceOnUnRegisterEvents + /// This function removes the name of the service from the notification object. + /// + /// \param [IN] f_cservicename + /// std::string - name of service unregistering from notification + /// + /// \param [IN] f_cnotificationname + /// std::string - notification name + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceServiceOnUnRegisterEvents(const std::string &f_cservicename, + const std::string &f_cnotificationname); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceServiceOnPublishEvent + /// This function stores the published data in the notification object in case of state and + /// persistent notification. + /// + /// \param [IN] f_cservicename + /// std::string - name of service registering for notification + /// + /// \param [IN] f_cnotificationname + /// std::string - notification name + /// + /// \param [IN] f_pmessage + /// PVOID - pointer to message + /// + /// \param f_uimsgsize + /// UI_32 - size of Message + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceServiceOnPublishEvent(const std::string &f_cservicename, + const std::string &f_cnotificationname, + PVOID f_pmessage, + const UI_32 f_uimsgsize); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceServiceOnSubscribeToEvent + /// This function adds the name of the application to subscribers list in notification object. + /// + /// \param [IN] f_csubscribername + /// std::string - name of application subscribing to notification + /// + /// \param [IN] f_cnotificationname + /// std::string - notification name + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceServiceOnSubscribeToEvent(const std::string &f_csubscribername, + const std::string &f_cnotificationname); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceServiceOnUnSubscribeFromEvent + /// This function adds the name of the application to subscribers list in notification object. + /// + /// \param [IN] f_csubscribername + /// std::string - name of application subscribing to notification + /// + /// \param [IN] f_cnotificationname + /// std::string - notification name + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceServiceOnUnSubscribeFromEvent(const std::string &f_csubscribername, + const std::string &f_cnotificationname); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NPGetPersistentNotificationData + /// Get data for notification name + /// + /// \param [IN] f_cnotificationname + /// std::string - name of notification + /// \param [OUT] f_pnotificationdata + /// PVOID - data corresponding to notification name + /// \param [IN] f_uidatasize + /// UI_32 - size of data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NPGetPersistentNotificationData(const std::string &f_cnotificationname, + PVOID f_pnotificationdata, const UI_32 f_uidatasize); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceServiceOnGetPersistentData + /// This function is used to get the persistent data stored related to notification. + /// + /// \param [IN] f_cnotificationname + /// std::string - Notification Name + /// + /// \param [IN] f_creceivername + /// std::string - Source Name + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceServiceOnGetPersistentData(const std::string &f_cnotificationname, + const std::string &f_creceivername); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceGetPersistentNotificationData + /// This function is used to get the list of persistent notifications and the data associated + /// with it. + /// + /// \param [OUT] f_pvpersistnotification + /// CNotificationsToPersist - vector containing list of persistent notifications and + /// data associated with it. + /// + /// \param [IN] f_enotificationtype + /// EFrameworkunifiedNotificationType - Type of notification + /// + /// \param [IN] f_uinotificationpersistentservicepersistcategoryflag + /// UI_32 - Hex value from enum EFrameworkunifiedPersistCategory, representing data to persist + /// 0 - persist orignal data and + /// 1 - persist default data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceGetPersistentNotificationData(std::vector<CNotificationsToPersist *> *f_pvpersistnotification, + const EFrameworkunifiedNotificationType f_enotificationtype, + UI_32 f_uinotificationpersistentservicepersistcategoryflag); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceSetPersistentNotificationData + /// This function is used to create the persistent notifications object and fill the data + /// related with it on system load. + /// + /// \param [IN] f_pvpersistnotification + /// vector<CNotificationsToPersist> - vector containing list of notifications and data associated with it + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceSetPersistentNotificationData(std::vector<CNotificationsToPersist *> *f_pvpersistnotification); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetNotificationInfo + /// This function is used to get the notification information. + /// + /// \param [IN] f_cnotificationname + /// std::string - Notification Name + /// + /// \param [IN] l_pnotificationstopersist + /// CNotificationsToPersist - Notification info structure + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus GetNotificationInfo(const std::string &f_cnotificationname, + CNotificationsToPersist *&l_pnotificationstopersist); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceSetDefaultPersistentNotificationData + /// This function is used to set the default data of persistent notification + /// + /// \param [IN] f_cnotificationname + /// std::string - notification name + /// \param [IN] f_pmessage + /// PVOID - message data + /// \param [IN] f_uimsgsize + /// UI_32 - message size + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceSetDefaultPersistentNotificationData(const std::string &f_cnotificationname, + PVOID f_pmessage, + const UI_32 f_uimsgsize); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceSetPersistentCategory + /// This function is used to set the persistent type of persistent notification + /// + /// \param [IN] f_cnotificationname + /// std::string - notification name + /// \param [IN] f_epersistenttype + /// EFrameworkunifiedPersistCategory - persistent category + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceSetPersistentCategory(const std::string &f_cnotificationname, + const EFrameworkunifiedPersistCategory f_epersistcategory); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// 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. + /// + /// \param [IN] f_cservicename + /// const std::string& - name of service registering for notification + /// + /// \param [IN] f_cnotificationname + /// const std::string& - notification name + /// + /// \param [IN] f_pmessage + /// PVOID - pointer to message + /// + /// \param f_uimsgsize + /// UI_32 - size of Message + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - eFrameworkunifiedStatusOK on success + /// eFrameworkunifiedStatusInvldParam - invalid parameter + /// eFrameworkunifiedStatusNullPointer - if notification not found + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentservicePublishImmediateNotification(const std::string &f_cservicename, + const std::string &f_cnotificationname, + PVOID f_pmessage, + const UI_32 f_uimsgsize); + +#ifdef NPP_PROFILEINFO_ENABLE + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetNotificationProfilingData + /// This function is used to get the notification profiling information. + /// + /// \param [OUT] f_tNotificationProfileInfo + /// std::string - all the notification info of all applications concated in a string + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus GetNotificationProfilingData(std::string &f_cnotificationprofileInfo); // NOLINT (runtime/references) + +#endif + + private: + Notification_Type *m_pmNotificationList; /// < map containing list of all notifications. + + std::vector<std::string> *m_pvPersistentList; /// < vector containing list of all persistent notifications. + + std::vector<std::string> *m_pvUserPersistentList; /// < vector containing list of all user persistent notifications. + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CreateNotificationObject + /// This function is used to get notification object from map if it exists else create new + /// object as per type of notification. + /// + /// \param [IN] f_cnotificationname + /// std::string - notification name + /// + /// \param [IN] f_uimsglength + /// UI_32 - Maximum size of notification message + /// + /// \param [IN] f_enotificationtype + /// EFrameworkunifiedPersistentVarType - Delay time for persistence + /// + /// \param [IN] f_uidelay + /// UI_32 - Persistence Delay + /// + /// \return CNotification + // CNotification - pointer of notification object + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CNotification *CreateNotificationObject(const std::string &f_cnotificationname, + const UI_32 f_uimsglength, + const EFrameworkunifiedNotificationType f_enotificationtype, + const UI_32 f_uidelay = 0); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SearchNotification + /// This function is used to search whether notification object is present in map or not. + /// If present it sends the reference. CNotification - reference to pointer of notification object + /// + /// \param [IN] f_cnotificationname + /// std::string - notification name + /// + /// \return CNotification + // CNotification - pointer of notification object + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CNotification *SearchNotification(const std::string &f_cnotificationname); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SearchPersistenceNotification + /// This function is used to search whether the given persistent notification object + /// is present in map or not. + /// + /// \param [IN] f_cnotificationname + /// std::string - notification name + /// + /// \return CStateNotification + // CStateNotification - pointer of notification object + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CStateNotification *SearchPersistenceNotification(const std::string &f_cnotificationname); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CreateNotificationObjectToPersist + /// Creates the CNotificationsToPersist object from notification object and the persistent data. + /// + /// \param [IN] f_pnotification + /// CStateNotification - notification object ptr + /// \param [IN] f_pdata + /// CPersistentData - persistent data + /// + /// \return CNotification + // CNotification - pointer of notification object + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CNotificationsToPersist *CreateNotificationObjectToPersist(CStateNotification *f_pnotification, + const CPersistentData *f_pdata); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// RemoveUserSpecificNotificationEntry + /// This function is used to get the singleton instance of class. + /// + /// \param + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus RemoveUserSpecificNotificationEntry(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ChangeNotificationType + /// This function creates new notification object depending on the type and replaces the old one. + /// The subscribers list is copied from the old notification object is copied to the new one. + /// + /// \param [IN] f_pnotification + /// CNotification* - old notification object + /// + /// \param [IN] f_cservicename + /// std::string - name of service registering for notification + /// + /// \param [IN] f_cnotificationname + /// std::string - notification name + /// + /// \param [IN] f_uimsglength + /// UI_32 - Maximum length of Message + /// + /// \param [IN] f_enotificationtype + /// EFrameworkunifiedPersistentVarType - new type of notification + /// + /// \param [IN] f_uidelay + /// UI_32 - Delay time for persistence + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus 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); +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOTIFICATION_MANAGER_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_notification_receiver.h b/nsframework/notification_persistent_service/server/include/ns_npp_notification_receiver.h new file mode 100644 index 00000000..09f6b151 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_notification_receiver.h @@ -0,0 +1,68 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contain declaration of class CNotificationReceiver. +/// It holds the handle of message queue for sending notification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOTIFICATION_RECEIVER_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOTIFICATION_RECEIVER_H_ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <native_service/frameworkunified_types.h> + +class CNotificationReceiver { + private: + // no members in private + + public: + HANDLE m_MsgQHandle; ///< handle to message queue + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CNotificationReceiver + /// Constructor of CNotificationReceiver class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CNotificationReceiver(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CNotificationReceiver + /// Destructor of CNotificationReceiver class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CNotificationReceiver(); +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOTIFICATION_RECEIVER_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_notificationpersistentservicelog.h b/nsframework/notification_persistent_service/server/include/ns_npp_notificationpersistentservicelog.h new file mode 100644 index 00000000..e668af6a --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_notificationpersistentservicelog.h @@ -0,0 +1,94 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief +/// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOTIFICATIONPERSISTENTSERVICELOG_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOTIFICATIONPERSISTENTSERVICELOG_H_ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <native_service/ns_logger_if.h> + +#define ZONE_INIT ZONEMASK(10) +#define ZONE_FUNC ZONEMASK(11) +#define ZONE_MEM ZONEMASK(12) +#define ZONE_13 ZONEMASK(13) +#define ZONE_14 ZONEMASK(14) +#define ZONE_15 ZONEMASK(15) +#define ZONE_16 ZONEMASK(16) +#define ZONE_17 ZONEMASK(17) +#define ZONE_18 ZONEMASK(18) +#define ZONE_19 ZONEMASK(19) +#define ZONE_20 ZONEMASK(20) +#define ZONE_21 ZONEMASK(21) +#define ZONE_22 ZONEMASK(22) +#define ZONE_23 ZONEMASK(23) +#define ZONE_24 ZONEMASK(24) +#define ZONE_NPP_INFO ZONEMASK(25) +#define ZONE_PRD_INFO3 ZONEMASK(26) +#define ZONE_PRD_INFO2 ZONEMASK(27) +#define ZONE_PRD_INFO1 ZONEMASK(28) +#define ZONE_INFO ZONEMASK(29) +#define ZONE_WARN ZONEMASK(30) +#define ZONE_ERR ZONEMASK(31) + +#define ZONE_TEXT_10 "Init" +#define ZONE_TEXT_11 "Function" +#define ZONE_TEXT_12 "Memory" +#define ZONE_TEXT_13 "" +#define ZONE_TEXT_14 "" +#define ZONE_TEXT_15 "" +#define ZONE_TEXT_16 "" +#define ZONE_TEXT_17 "" +#define ZONE_TEXT_18 "" +#define ZONE_TEXT_19 "" +#define ZONE_TEXT_20 "" +#define ZONE_TEXT_21 "" +#define ZONE_TEXT_22 "" +#define ZONE_TEXT_23 "" +#define ZONE_TEXT_24 "" +#define ZONE_TEXT_25 "NPP Info" +#define ZONE_TEXT_26 "Product Info3" +#define ZONE_TEXT_27 "Product Info2" +#define ZONE_TEXT_28 "Product Info1" +#define ZONE_TEXT_29 "Info" +#define ZONE_TEXT_30 "Warning" +#define ZONE_TEXT_31 "Error" + +#ifndef FRAMEWORKUNIFIEDLOGOPTIONS +#define FRAMEWORKUNIFIEDLOGOPTIONS (LPRINT) // LPRINT , LMSGQ, LSLOGGER +#endif + +#ifndef FRAMEWORKUNIFIEDLOGAPPZONES +#define FRAMEWORKUNIFIEDLOGAPPZONES ZONE_WARN, ZONE_ERR, ZONE_NS_WAR, ZONE_NS_ERR, ZONE_PRD_INFO2 +#endif + +extern const CHAR AppName[]; // NOLINT (readability/naming) +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_NOTIFICATIONPERSISTENTSERVICELOG_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_persist_file.h b/nsframework/notification_persistent_service/server/include/ns_npp_persist_file.h new file mode 100644 index 00000000..04468bee --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_persist_file.h @@ -0,0 +1,121 @@ +/* + * @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 CFilePersistence class. +/// This class is responsible for persisting and retrieving of files. +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSIST_FILE_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSIST_FILE_H_ + +#include <native_service/ns_np_service.h> +#include <string> +#include <map> +#include "ns_npp_persistence.h" + +// Forward declaration of classes. +class CPersistence; +class CRegistryEntry; + +/** + * This class is responsible for persisting and retrieving of files.. + */ +class CFilePersistence : public CPersistence { + private: + TSourceRegistryList m_mPersistFileRegistry; + + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CFilePersistence + /// Constructor of CFilePersistence class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CFilePersistence(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CFilePersistence + /// Destructor of CFilePersistence class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CFilePersistence(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Release + /// Request for release file to persistent storage. File persist will be done at shutdown. + /// + /// \param [IN] f_cappname + /// string - Name of the application requesting for persistence + /// + /// \param [IN] f_ctag + /// string - File will be persist against this tag. + /// + /// \param [IN] f_cmempath + /// string - File which needs to persist. + /// + /// \param [IN] enotificationpersistentservicereleasetype + /// EFrameworkunifiedReleaseType - eFrameworkunifiedNotOnRelease = 0 :not on release + /// eFrameworkunifiedPersistOnShutdown :persist on shutdown + /// eFrameworkunifiedPersistInstantly :persist instantly + /// + /// \param [IN] f_cusername + /// std::string - If tag is registered as user, then f_cusername holds the name of user, + /// else an empty string + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus Release(std::string f_cappname, std::string f_ctag, std::string f_cmempath, + EFrameworkunifiedReleaseType enotificationpersistentservicereleasetype, std::string f_cusername); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Load + /// Load file from persistent memory to the specified location. + /// + /// \param [IN] f_cappname + /// string - Name of the application requesting for persistence + /// + /// \param [IN] f_ctag + /// string - File corresponding to this tag will be retrieved. + /// + /// \param [IN] f_cretrievepath + /// string - Filepath for retrieved file. + /// + /// \param [IN] f_cusername + /// std::string - If tag is registered as user, then f_cusername holds the name of user, + /// else an empty string + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus Load(std::string f_cappname, std::string f_ctag, std::string f_cretrievepath, + std::string f_cusername); +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSIST_FILE_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_persist_folder.h b/nsframework/notification_persistent_service/server/include/ns_npp_persist_folder.h new file mode 100644 index 00000000..39cf9753 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_persist_folder.h @@ -0,0 +1,122 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSIST_FOLDER_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSIST_FOLDER_H_ + +#include <native_service/frameworkunified_framework_if.h> +#include <string> + +#include "ns_npp_persistence.h" + + +// class CPersistence; + +class CFolderPersistence : public CPersistence { + private: + TSourceRegistryList m_mPersistFolderRegistry; // map to hold the folder registry entries + + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CFolderPersistence + /// Constructor of CFolderPersistence class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CFolderPersistence(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CFolderPersistence + /// Destructor of CFolderPersistence class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CFolderPersistence(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Release + /// Entry for the folder is stored in map for persistence. + /// If f_bPersist is TRUE folder will be persisted immediately else will be persisted on shutdown + /// + /// \param [IN] f_cappname + /// string - Name of the application requesting for persistence + /// + /// \param [IN] f_ctag + /// string - Folder will be persist against this tag. + /// + /// \param [IN] f_cmempath + /// string - Folder which needs to persist. + /// + /// \param [IN] enotificationpersistentservicereleasetype + /// EFrameworkunifiedReleaseType - eFrameworkunifiedNotOnRelease = 0 :not on release + /// eFrameworkunifiedPersistOnShutdown :persist on shutdown + /// eFrameworkunifiedPersistInstantly :persist instantly + /// + /// \param [IN] f_cusername + /// std::string - If tag is registered as user, then f_cusername holds the name of user, + /// else an empty string + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus Release(std::string f_crequesterappname, + std::string f_ctag, + std::string f_cmempath, + EFrameworkunifiedReleaseType enotificationpersistentservicereleasetype, + std::string f_cusername); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Load + /// Load folder from persistent memory to the specified location. + /// + /// \param [IN] f_cappname + /// string - Name of the application requesting for persistence + /// + /// \param [IN] f_ctag + /// string - Folder corresponding to this tag will be retrieved. + /// + /// \param [IN] f_cretrievepath + /// string - Filepath for retrieved file. + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus Load(std::string f_cappname, + std::string f_ctag, + std::string f_cretrievepath, + std::string f_cusername); +}; +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSIST_FOLDER_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_persistence.h b/nsframework/notification_persistent_service/server/include/ns_npp_persistence.h new file mode 100644 index 00000000..d84f9fbe --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_persistence.h @@ -0,0 +1,365 @@ +/* + * @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 CPersistence class. +/// This is a abstract class for file and folder persistency. +/// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSISTENCE_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSISTENCE_H_ + +#include <native_service/frameworkunified_types.h> +#include <native_service/ns_np_service.h> +#include <string> +#include <map> +#include <list> + +#include "ns_npp_notificationpersistentservicelog.h" +#include "ns_npp_copy_worker.h" + +class CRegistryEntry; + +typedef std::string TSourceName; +typedef std::string TTag; +typedef std::map< TTag, CRegistryEntry > TTagRegistryList; +typedef TTagRegistryList::iterator TTagRegistryListItr; + +typedef std::map<TSourceName, TTagRegistryList> TSourceRegistryList; +typedef TSourceRegistryList::iterator TSourceRegistryListItr; + +typedef std::list<NSP_CopyInfoCmd> TPendingJobs; +typedef TPendingJobs::iterator TPendingJobsItr; + +/** + * This is a abstract class for file and folder persistence. + */ +class CPersistence { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CPersistence + /// Constructor of CPersistence class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CPersistence(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CPersistence + /// Destructor of CPersistence class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual ~CPersistence(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Register + /// Register file/folder tag for persistence. + /// + /// \param [IN] f_cappname + /// string - Name of the application requesting for persistence + /// + /// \param [IN] f_ctag + /// string - File/Folder corresponding to this tag will be retrieved. + /// + /// \param [IN] bisuserpersistence + /// BOOL - TRUE if user persistence else FALSE + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus Register(std::string f_crequestorappname, std::string f_ctag, BOOL bisuserpersistence); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Release + /// Entry for the file/Folder is stored in map for persistence. + /// If f_bPersist is TRUE file/folder will be persisted immediately else will be persist on shutdown + /// + /// \param [IN] f_cappname + /// string - Name of the application requesting for persistence + /// + /// \param [IN] f_ctag + /// string - File/Folder will be persist against this tag. + /// + /// \param [IN] f_cmempath + /// string - File/Folder path that is to be persisted. + /// + /// \param [IN] enotificationpersistentservicereleasetype + /// EFrameworkunifiedReleaseType - eFrameworkunifiedNotOnRelease = 0 :not on release + /// eFrameworkunifiedPersistOnShutdown :persist on shutdown + /// eFrameworkunifiedPersistInstantly :persist instantly + /// + /// \param [IN] f_cusername + /// std::string - If tag is registered as user, then f_cusername holds the name of user, + /// else an empty string + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus Release(std::string f_cappname, + std::string f_ctag, + std::string f_cmempath, + EFrameworkunifiedReleaseType enotificationpersistentservicereleasetype, + std::string f_cusername) = 0; + + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Load + /// Load file/folder from persistent memory to the specified location. + /// + /// \param [IN] f_cappname + /// string - Name of the application requesting for persistence + /// + /// \param [IN] f_ctag + /// string - File/Folder corresponding to this tag will be retrieved. + /// + /// \param [IN] f_cretrievepath + /// string - Path to retrieve. + /// + /// \param [IN] f_cusername + /// std::string - If tag is registered as user, then f_cusername holds the name of user, + /// else an empty string + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus Load(std::string f_cappname, + std::string f_ctag, + std::string f_cretrievepath, + std::string f_cusername) = 0; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Persist + /// Persist file/folder immediately + /// + /// \param [IN] f_objregistryentry + /// CRegistryEntry& - Registry entry job object to persist. + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus Persist(CRegistryEntry &f_objregistryentry); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////// + /// AckReceivedFromWorker + /// + /// + /// \param [in] pSource + /// PCSTR - Name of the source. + /// \param [in] f_ctag + /// PCSTR - file/folder tag. + /// \param [in] f_bcopystatus + /// BOOL - Status of file/folder copy by copy worker. + /// \param [in] f_eloadtype + /// ENPS_Loadtype - Type of load release or load. + /// + /// \return status + /// EFrameworkunifiedStatus - success or error + //////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus AckReceivedFromWorker(PCSTR f_csource, PCSTR f_ctag, BOOL f_bcopystatus, + ENPS_Loadtype f_eloadtype); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// PersistAllReleaseRequests + /// Persist all files/folders which are not persisted yet. + /// + /// \param [in] f_uinotificationpersistentservicepersistcategoryflag + /// UI_32 - Hex value from enum EFrameworkunifiedPersistCategory, representing data to persist + /// 0 - persist orignal data and + /// 1 - persist default data + /// + /// \return status + /// EFrameworkunifiedStatus - success or error + //////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus PersistAllReleaseRequests(UI_32 f_uinotificationpersistentservicepersistcategoryflag); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// HaveAllReleaseRequestsPersisted + /// Checks if all release requests are processed or not + /// + /// \param [out] f_ctagnotreleased + /// std::string - list of tags not released by application + /// + /// \return BOOL + /// TRUE if all release requests are processed else false + //////////////////////////////////////////////////////////////////////////////////////////// + BOOL HaveAllReleaseRequestsPersisted(std::string &f_ctagnotreleased); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////// + /// ResetPersistFlag + /// Resets persist flag. + /// + /// \param none + /// + /// \return none + //////////////////////////////////////////////////////////////////////////////////////////// + VOID ResetPersistFlag(); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// PersistAllUserRequests + /// Persist all files/folders which are not persisted yet. + /// + /// + /// \return status + /// EFrameworkunifiedStatus - success or error + //////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus PersistAllUserRequests(); + + // virtual VOID ListAllInMap() = 0; + + //////////////////////////////////////////////////////////////////////////////////////////// + /// SetReadThreadHandle + /// Set read thread handle. + /// + /// \param [in] f_hreadthread + /// HANDLE - Handle of the read thread. + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////// + VOID SetReadThreadHandle(HANDLE f_hreadthread); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// SetWriteThreadHandle + /// Set write thread handle. + /// + /// \param [in] f_hwritethread + /// HANDLE - Handle of the write thread. + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////// + VOID SetWriteThreadHandle(HANDLE f_hwritethread); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// GetStoragePath + /// Get the permanent storage path. Get it from NS_NPPService's config file. + /// + /// \return std::string + /// std::string - Permanant storage path + //////////////////////////////////////////////////////////////////////////////////////////// + static std::string GetStoragePath(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetPersistentCategory + /// Sets the persist type of file/folder + /// + /// \param [IN] f_crequestorname + /// string - Application Name + /// + /// \param [IN] f_ctag + /// string - File/Folder will be persist against this tag. + /// + /// \param [IN] f_epersistcategory + /// EFrameworkunifiedPersistCategory - persistent category + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus SetPersistentCategory(const std::string &f_crequestorname, + const std::string &f_ctag, + EFrameworkunifiedPersistCategory f_epersistcategory); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// IsUserPersistence + /// Check if the file/folder being persisted is user specific + /// + /// \param [in] - f_ctag + /// std::string - File/Folder Tag + /// + /// \return status + /// BOOL - TRUE for user specific persistence + /// FALSE for global persistence + /////////////////////////////////////////////////////////////////////////////////////////// + virtual BOOL IsUserPersistence(std::string f_ctag); + +#ifdef NPP_PROFILEINFO_ENABLE + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetPersistenceProfilingData + /// This function is used to get the persistence info + /// + /// \param [out] f_cpersistenceprofileinfo + /// std::string - Persistence info concated in a string + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - success or failure + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus GetPersistenceProfilingData(std::string &f_cpersistenceprofileinfo); // NOLINT (runtime/references) + +#endif + + protected: + EFrameworkunifiedStatus ProcessReleaseRequest(std::string f_crequesterappname, + std::string f_ctag, + ENotificationpersistentservicePersistType f_epersisttype, + std::string f_cmempath, + EFrameworkunifiedReleaseType enotificationpersistentservicereleasetype, + std::string f_cusername); + + EFrameworkunifiedStatus ProcessLoadRequest(std::string f_crequesterappname, + std::string f_ctag, + ENotificationpersistentservicePersistType f_epersisttype, + std::string f_cretrievepath, + std::string f_cusername); + + VOID AddRequestData(NSP_CopyInfoCmd &f_tcpinfo, // NOLINT (runtime/references) + std::string f_sourcepath, + std::string f_destpath, + std::string f_crequesterappname, + std::string f_ctag, + ENPS_Loadtype f_eloadtype, + ENotificationpersistentservicePersistType f_epersisttype); + + EFrameworkunifiedStatus SendRequestMessage(NSP_CopyInfoCmd &f_tcpinfo); // NOLINT (runtime/references) + + std::string m_cStoragePath; ///< Persistent memory storage path + + NOTIFICATIONPERSISTENTSERVICE_COMPRESSION_TYPE m_eCompressionType; ///< Compression type for file/folder persistency + + HANDLE m_hNSWriteToPersistentMem; ///< Child thread handle, copies file to persistent memory. + + HANDLE m_hNSReadFromPersistentMem; ///< Child thread handle, copies file from persistent memory. + + // TODO(my_username): Remove this member var. Once the API to get application handle is available, use that. + HANDLE m_hAppHandle; + + TSourceRegistryList m_mPersistRegistry; + + TPendingJobs m_lPendingJobs; ///< stores the list of pending jobs sequentially + + BOOL m_bPersist; ///< persist or not. It will be set to TRUE either on shutdown or userchange + + UI_32 m_uiNotificationpersistentservicePersistCategoryFlag; ///< Stores the persist category flag value on shutdown request. + ///< It is needed to decide which data to persist, if + ///< release request is received by NSNPP after shutdown request +}; +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSISTENCE_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_persistence_manager.h b/nsframework/notification_persistent_service/server/include/ns_npp_persistence_manager.h new file mode 100644 index 00000000..99f98d7e --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_persistence_manager.h @@ -0,0 +1,536 @@ +/* + * @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 CPersistenceManager class. +/// This class acts as a manager for notification persistent data storage +/// and file and folder persistence. +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSISTENCE_MANAGER_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSISTENCE_MANAGER_H_ + + +#include <native_service/frameworkunified_types.h> +#include <native_service/ns_np_service.h> +#include <map> +#include <string> +#include <vector> +#include "ns_npp_types.h" +#include "ns_npp_persistent_accesser.h" + +class CPersistence; +class CPersistentData; +class CNotificationsToPersist; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// vector of all available persistent notification and its data. +//////////////////////////////////////////////////////////////////////////////////////////////////// +typedef std::vector<CNotificationsToPersist *> Persistent_Notification_List_Type; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// Map of all persist file type. i.e. FilePersistence and FolderPersistence +//////////////////////////////////////////////////////////////////////////////////////////////////// +typedef std::map<ENotificationpersistentservicePersistType, CPersistence *> Persist_Type; + +typedef Persist_Type::iterator Persist_Type_Iter; + +/** + * This class acts as a manager for storing notification data,file and folder in + * persistent memory. + */ +class CPersistenceManager { + public: + /// Disable Persistence + static BOOL m_bPersistenceDisabled; // NOLINT (readability/naming) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CPersistenceManager + /// Constructor of CPersistenceManager class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CPersistenceManager(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CPersistenceManager + /// Destructor of CPersistenceManager class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CPersistenceManager(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceRegister + /// Registers a tag for the file or folder. This tag will be used for releasing or loading a + /// file or folder. + /// + /// \param [IN] f_cappname + /// string - Name of the application requesting for persistence + /// + /// \param [IN] f_ctag + /// string - File/Folder will be persist against this tag. + /// + /// \param [IN] f_epersisttype + /// ENotificationpersistentservicePersistType - ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE - Tag to register is for a file + /// ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER - Tag to register is for a folder + /// + /// \param [IN] bisuserpersistence + + /// BOOL - TRUE if user persistence else FALSE + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - success or failure status + /// + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceRegister(std::string f_cappname, + std::string f_ctag, + ENotificationpersistentservicePersistType f_epersisttype, + BOOL bisuserpersistence); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceRelease + /// Entry for the file or folder is stored in map for persistence. + /// If f_bPersist is TRUE file or folder will be persist immediately else will be persist + /// on shutdown + /// + /// \param [IN] f_cappname + /// string - Name of the application requesting for persistence + /// + /// \param [IN] f_ctag + /// string - File/Folder will be persist against this tag. + /// + /// \param [IN] f_cmempath + /// string - File/Folder which needs to persist. + /// + /// \param [IN] enotificationpersistentservicereleasetype + /// EFrameworkunifiedReleaseType - eFrameworkunifiedNotOnRelease = 0 :not on release + /// eFrameworkunifiedPersistOnShutdown :persist on shutdown + /// eFrameworkunifiedPersistInstantly :persist instantly + /// + /// \param [IN] f_epersisttype + /// ENotificationpersistentservicePersistType - ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE - Persist a file to a persistent memory + /// ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER - Persist a folder to a persistent memory + /// + /// \param [IN] f_cusername + /// std::string - If tag is registered as user, then f_cusername holds the name of user, + /// else an empty string + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceRelease(std::string f_cappname, + std::string f_ctag, + std::string f_cmempath, + EFrameworkunifiedReleaseType enotificationpersistentservicereleasetype, + ENotificationpersistentservicePersistType f_epersisttype, + std::string f_cusername); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceLoad + /// Load file/folder from persistent memory to the specified location. + /// + /// \param [IN] f_cappname + /// string - Name of the application requesting for persistence + /// + /// \param [IN] f_ctag + /// string - File/Folder corresponding to this tag will be retrieved. + /// + /// \param [IN] f_cretrievepath + /// string - Filepath for retrieved file/folder. + /// + /// \param [IN] f_epersisttype + /// ENotificationpersistentservicePersistType - ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE - Load a file from persistent memory + /// ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER - Load a folder from persistent memory + /// + /// \param [IN] f_cusername + /// std::string - If tag is registered as user, then f_cusername holds the name of user, + /// else an empty string + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceLoad(std::string f_cappname, + std::string f_ctag, + std::string f_cretrievepath, + ENotificationpersistentservicePersistType f_epersisttype, + std::string f_cusername); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// AckReceivedFromWorker + /// Send release ack to file/folder persistence object. + /// + /// \param [IN] f_csource + /// PCSTR - Source of released file/folder + /// + /// \param [IN] f_ctag + /// PCSTR - Tag of released file/folder + /// + /// \param [IN] f_epersisttype + /// ENotificationpersistentservicePersistType - ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE - Ack for file persistence object + /// ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER - Ack for folder persistence object + /// + /// \param [in] f_bcopystatus + /// BOOL - Status of file/folder copy by worker. + /// + /// \param [in] f_eloadtype + /// ENPS_Loadtype - Type of load release or load. + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus AckReceivedFromWorker(PCSTR f_csource, PCSTR f_ctag, ENotificationpersistentservicePersistType f_epersisttype, + BOOL f_bcopystatus, ENPS_Loadtype f_eloadtype); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceSaveNotificationData + /// Save notification data in a persistent file. + /// + /// \param [IN] f_vpersistentnotificationlist + /// Persistent_Notification_List_Type - List of all notifications and corresponding data. + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceSaveNotificationData(Persistent_Notification_List_Type *f_vpersistentnotificationlist); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceSaveUserNotificationData + /// Save notification data of user in a persistent file. + /// + /// \param [IN] f_vpersistentnotificationlist + /// Persistent_Notification_List_Type - List of all notifications and corresponding data. + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceSaveUserNotificationData(Persistent_Notification_List_Type *f_vpersistentnotificationlist); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceReadNotificationData + /// Get the list of all persistent notifications from a persistent memory and store it in a map. + /// + /// \param [OUT] f_vpersistentnotificationlist + /// Persistent_Notification_List_Type - Retrieved list of all notifications and corresponding data + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceReadNotificationData(Persistent_Notification_List_Type *&f_vnotificationlist); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceReadUserNotificationData + /// Get the list of all user persistent notifications from a persistent memory and store it in a map. + /// + /// \param [OUT] f_vpersistentnotificationlist + /// Persistent_Notification_List_Type - Retrieved list of all notifications and corresponding data + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceReadUserNotificationData(Persistent_Notification_List_Type *&f_vnotificationlist); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceReadNorNotificationData + /// Get the list of all Nor persistent notifications from a persistent memory and store it in a map. + /// + /// \param [OUT] f_vpersistentnotificationlist + /// Persistent_Notification_List_Type - Retrieved list of all notifications and corresponding data + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceReadNorNotificationData(Persistent_Notification_List_Type *&f_vnotificationlist); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// PersistAllReleaseRequests + /// Persist all files and folder contained in the map in persistent memory. + /// + /// \param [in] f_uinotificationpersistentservicepersistcategoryflag + /// UI_32 - Hex value from enum EFrameworkunifiedPersistCategory, representing data to persist + /// 0 - persist orignal data and + /// 1 - persist default data + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus PersistAllReleaseRequests(UI_32 f_uinotificationpersistentservicepersistcategoryflag); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentservicePersistAllUserRequests + /// Persist all user files and folder contained in the map in persistent memory. + /// + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentservicePersistAllUserRequests(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetReadThreadHandle + /// Pass the handle of the read thread to the object of file/folder persistence + /// + /// \param [IN] f_hreadthread + /// HANDLE - Handle of read thread. + /// + /// \return + /// + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + VOID SetReadThreadHandle(HANDLE f_hreadthread); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetWriteThreadHandle + /// Pass the handle of the write thread to the object of file/folder persistence + /// + /// \param [IN] f_hwritethread + /// HANDLE - Handle of write thread. + /// + /// \return + /// + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + VOID SetWriteThreadHandle(HANDLE f_hwritethread); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetNorPersistenceThreadHandle + /// Pass the handle of the Nor persistence write thread to the object of file/folder persistence + /// + /// \param [IN] f_hwritethread + /// HANDLE - Handle of write thread. + /// + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + VOID SetNorPersistenceThreadHandle(HANDLE f_hwritethread); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetUserPersistentPath + /// Set user persistent path. + /// + /// \param [IN] f_cusername + /// std::string - Name of user + /// + /// \return + /// + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + VOID SetUserPersistentPath(std::string f_cusername); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// IsUserPersistence + /// Check if the persistence is user specific + /// + /// \param [in] - f_ctag + /// std::string - File/folder Tag + /// + /// \param [in] - f_epersisttype + /// ENotificationpersistentservicePersistType - persistent type + /// + /// \return status + /// BOOL - TRUE for user specific persistence + /// FALSE for global persistence + /////////////////////////////////////////////////////////////////////////////////////////// + BOOL IsUserPersistence(std::string f_ctag, ENotificationpersistentservicePersistType f_epersisttype); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// HaveAllReleaseRequestsPersisted + /// Checks if all files and immediate persistent data are persisted. + /// + /// \param + /// + /// \return BOOL + /// TRUE if all release requests are processed else false + //////////////////////////////////////////////////////////////////////////////////////////// + BOOL HaveAllReleaseRequestsPersisted(); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// ResetPersistFlag + /// Resets persist flag. + /// + /// \param none + /// + /// \return none + //////////////////////////////////////////////////////////////////////////////////////////// + VOID ResetPersistFlag(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ClearPersistenceData + /// Deletes the data from the persistent memory + /// + /// \param [in] f_enotificationpersistentserviceclearpersistencescope + /// EFrameworkunifiedClearPersistence - data to be deleted from memory + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - success or failure + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus ClearPersistenceData(const EFrameworkunifiedClearPersistence &f_enotificationpersistentserviceclearpersistencescope); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceSetPersistentCategory + /// Sets the persist type of file or folder + /// + /// \param [IN] f_crequestorname + /// string - Application name + /// + /// \param [IN] f_ctag + /// string - File/Folder will be persist against this tag. + /// + /// \param [IN] f_epersistcategory + /// EFrameworkunifiedPersistCategory - persistent category + /// + /// \param [IN] f_bPersist + /// ENotificationpersistentservicePersistType - file or folder + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceSetPersistentCategory(std::string f_crequestorname, + std::string f_ctag, + EFrameworkunifiedPersistCategory f_epersistcategory, + ENotificationpersistentservicePersistType f_epersisttype); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// 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. + /// + /// \param f_eshutdowntype + /// EFrameworkunifiedShutdownType - shutdown type - normal, quick, data reset + /// + /// \param f_uinotificationpersistentservicepersistcategoryflag + /// UI_32 - flag representing whether to persist or reset data. + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus PersistNORData(EFrameworkunifiedShutdownType f_eshutdowntype, UI_32 f_uinotificationpersistentservicepersistcategoryflag); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// SetImmediateDataPersistedStatus + /// Set/Reset the persistence status of immediate persistence data + /// + /// \param [in] - f_bstatus + /// BOOL + /// TRUE - immediate persistent data are persisted + /// FALSE - immediate persistent data not persisted + /// + /// \return + /////////////////////////////////////////////////////////////////////////////////////////// + VOID SetImmediateDataPersistedStatus(BOOL f_bstatus); + + //////////////////////////////////////////////////////////////////////////////////////////// + /// SetFilePersistedStatus + /// Set/Reset the persistence status of files and folders + /// + /// \param [in] - f_bstatus + /// BOOL + /// TRUE - all files are persisted + /// FALSE - all files and folders are not persisted + /// + /// \return + /////////////////////////////////////////////////////////////////////////////////////////// + VOID SetFilePersistedStatus(BOOL f_bstatus); + +#ifdef NPP_PROFILEINFO_ENABLE + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetPersistenceProfilingData + /// This function is used to get the persistence info + /// + /// \param [out] f_cpersistenceprofileinfo + /// std::string - Persistence info concated in a string + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - success or failure + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus GetPersistenceProfilingData(std::string &f_cpersistenceprofileinfo); // NOLINT (runtime/references) + +#endif + + private: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ReadImmediateNotificationData + /// Get the list of all immediate persistent notifications of f_epersistcategory + /// from a persistent memory in a vector. + /// + /// \param [OUT] f_vpersistentnotificationlist + /// Persistent_Notification_List_Type - Retrieved list of all notifications and corresponding data + /// + /// \param [IN] f_epersistcategory + /// const EFrameworkunifiedPersistCategory - persistent category + /// + /// \return EFrameworkunifiedStatus + /// EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus ReadImmediateNotificationData(Persistent_Notification_List_Type *&f_vpersistentnotificationlist, // NOLINT (runtime/references) + const EFrameworkunifiedPersistCategory f_epersistcategory); + + std::string m_cUserNotificationTag; ///< Tag associated with a file which is used + ///< for storing user related notification persistent data. + + std::string m_cNotificationPersistFilepath; ///< Persistent file path for storing persistent data + + std::string m_cNotificationUserMemFilepath; ///< Memory location of a file for storing persistent data of a user + + Persist_Type m_mPersist_Type; ///< Map holds the objects of file and folder persistency. + + CPersistentAccesser *m_poDataAccesser; ///< Object for persistent data accesser + + HANDLE m_hNSImmediatePersistenceThread; ///< Nor persistence thread handle + + BOOL m_bAllFilePersisted; // all files have been persisted + + BOOL m_bImmediatedDataPersisted; // all immediate peristence data have been persisted + + EFrameworkunifiedStatus Init(); +}; + +//////////////////////////////////////////////////////////////////////////////////////////// +/// NPServiceOnCpWorkerAckCmd +/// Handles when the CopyWorker sends an ack back for a message received . +/// +/// \param [in] f_happ +/// HANDLE - Handle to notificationpersistentservice_application Framework. +/// +/// \return status +/// EFrameworkunifiedStatus - success or error +//////////////////////////////////////////////////////////////////////////////////////////// +EFrameworkunifiedStatus NPServiceOnCpWorkerAckCmd(HANDLE f_happ); + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSISTENCE_MANAGER_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_persistent_accesser.h b/nsframework/notification_persistent_service/server/include/ns_npp_persistent_accesser.h new file mode 100644 index 00000000..bfb15386 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_persistent_accesser.h @@ -0,0 +1,119 @@ +/* + * @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 CPersistentAccesser class. +/// This is a abstract class. Derived classes of this class will store the data in different +/// file formats. +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSISTENT_ACCESSER_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSISTENT_ACCESSER_H_ + +#include <native_service/frameworkunified_types.h> +#include <string> +#include <vector> + +class CPersistentData; +class CNotificationsToPersist; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// vector of all available persistent notification and its data. +//////////////////////////////////////////////////////////////////////////////////////////////////// +typedef std::vector<CNotificationsToPersist *> Persistent_Notification_List_Type; + +/** + * This is a abstract class. Derived classes of this class will store the data in different + * file formats. + */ +class CPersistentAccesser { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CPersistentAccesser + /// Constructor of CPersistentAccesser class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CPersistentAccesser() {} + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CPersistentAccesser + /// Destructor of CPersistentAccesser class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual ~CPersistentAccesser() { // LCOV_EXCL_START 14: Resident process, global instance not released + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + } + // LCOV_EXCL_STOP + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// PersistData + /// Persist data in persistent memory depending on file format. + /// + /// \param [IN] f_vpersistentnotificationlist + /// Persistent_Notification_List_Type - Data which has to be persisted. + /// + /// \param [IN] f_cmemfilepath + /// std::string - Read data from this file. + /// + /// \param [IN] f_epersistenttype + /// EFrameworkunifiedNotificationType - Type of persistent notification + /// + /// \param [IN] f_epersistcategory + /// EFrameworkunifiedPersistCategory - persist category + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus PersistData(std::string f_cmemfilepath, + Persistent_Notification_List_Type *f_vpersistentnotificationlist, + EFrameworkunifiedNotificationType f_epersistenttype, + EFrameworkunifiedPersistCategory f_epersistcategory = eFrameworkunifiedUserData) = 0; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// RetrieveData + /// Retrieve data in persistent memory depending on file format. + /// + /// \param [IN] f_cmemfilepath + /// std::string - Write data from this file. + /// + /// \param [IN] f_vpersistentnotificationlist + /// Persistent_Notification_List_Type* - Retrieved data. + /// + /// \param [IN] f_epersistcategory + /// EFrameworkunifiedPersistCategory - persist category + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus RetrieveData(std::string f_cmemfilepath, + Persistent_Notification_List_Type *&f_vpersistentnotificationlist, // NOLINT (runtime/references) + EFrameworkunifiedPersistCategory f_epersistcategory = eFrameworkunifiedUserData) = 0; +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSISTENT_ACCESSER_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_persistent_data.h b/nsframework/notification_persistent_service/server/include/ns_npp_persistent_data.h new file mode 100644 index 00000000..84e2b433 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_persistent_data.h @@ -0,0 +1,165 @@ + /* + * @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 conains declaration of CPersistentData, CNotificationsToPersist and CPersistDataHeader class. +/// This class is used to hold the persistent data related to state and persistent +/// notification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSISTENT_DATA_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSISTENT_DATA_H_ + +#include <native_service/frameworkunified_types.h> +#include <string> + +#ifdef AGL_STUB +#include <cstring> +#endif +/** + * This class holds the message and message length of notification data. + */ +class CPersistentData { + private: + // no members in private + + public: + PVOID m_pMessage; ///< pointer to message structure + + UI_32 m_uiMsgSize; ///< length of message + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CPersistentData + /// Constructor of CPersistentData class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CPersistentData(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CPersistentData + /// Destructor of CPersistentData class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CPersistentData(); +}; + +class CNotificationsToPersist { + private: + // no members in private + + public: + std::string m_cNotificationName; ///< Name of Notification + + UI_32 m_uiMaxMsgLength; ///< Maximum data length of notification + + EFrameworkunifiedNotificationType m_ePersistentType; ///< type of notification + + EFrameworkunifiedPersistCategory m_ePersistCategory; ///< Persistent category + + std::string m_cPublisherName; ///< Service Name + + CPersistentData *m_pPersistentData; ///< Persistent data related to notification + + UI_32 m_uiDelay; ///< Maximum delay for persistence + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CNotificationsToPersist + /// Constructor of CNotificationsToPersist class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CNotificationsToPersist(): m_cNotificationName(""), + m_uiMaxMsgLength(0), + m_ePersistentType(eFrameworkunifiedUnknown), + m_ePersistCategory(eFrameworkunifiedUserData), + m_cPublisherName(""), + m_pPersistentData(NULL), + m_uiDelay(0) { + } + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CNotificationsToPersist + /// Destructor of CNotificationsToPersist class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CNotificationsToPersist() { + if (NULL != m_pPersistentData) { // LCOV_EXCL_BR_LINE 6: m_pPersistentData can't be NULL + delete m_pPersistentData; + m_pPersistentData = NULL; + } + } +}; + +class CPersistDataHeader { + private: + // no members in private + + public: + UI_32 m_uiSize; ///< size of the associated data blob + UI_32 m_uiOffset; ///< Offset at which the data blob starts + EFrameworkunifiedNotificationType m_ePersistentType; + CHAR m_cPublisherName[MAX_QUEUE_NAME_SIZE]; + CHAR m_cNotificationName[MAX_STRING_SIZE_NOTIFICATION]; + UI_32 m_uiMaxMsgLength; ///< max size of the associated data + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CPersistDataHeader + /// Constructor of CPersistDataHeader class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CPersistDataHeader(): m_uiSize(0), + m_uiOffset(0), + m_ePersistentType(eFrameworkunifiedPersistedStateVar), + m_uiMaxMsgLength(0) { + std::memset(m_cPublisherName, 0, MAX_QUEUE_NAME_SIZE); + std::memset(m_cNotificationName, 0, MAX_STRING_SIZE_NOTIFICATION); + } + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CPersistDataHeader + /// Destructor of CPersistDataHeader class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CPersistDataHeader() { + } +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSISTENT_DATA_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_personality.h b/nsframework/notification_persistent_service/server/include/ns_npp_personality.h new file mode 100644 index 00000000..9ac052f2 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_personality.h @@ -0,0 +1,75 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contain declaration of CNotificationpersistentservicePersonality class. +/// The class object define personality. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSONALITY_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSONALITY_H_ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#include <native_service/frameworkunified_types.h> +#include <string> + +/** + * This class holds all the informations related to a personality. + */ +class CNotificationpersistentservicePersonality { + private: + // no members in private + + public: + std::string m_cUserName; ///< user name + + UI_32 m_uiUserId; ///< unique identifier of each user + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CNotificationpersistentservicePersonality + /// Constructor of CNotificationpersistentservicePersonality class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CNotificationpersistentservicePersonality(): m_cUserName(""), m_uiUserId(0) {} // LCOV_EXCL_BR_LINE 11: unexpected branch + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CNotificationpersistentservicePersonality + /// Destructor of CNotificationpersistentservicePersonality class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CNotificationpersistentservicePersonality() {} +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSONALITY_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_personalization_manager.h b/nsframework/notification_persistent_service/server/include/ns_npp_personalization_manager.h new file mode 100644 index 00000000..b1042fbe --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_personalization_manager.h @@ -0,0 +1,132 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains declaration of singleton class CnotificationpersistentservicePersonalizationManager which is +/// used to manage information of personality. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSONALIZATION_MANAGER_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSONALIZATION_MANAGER_H_ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#include <string> +#include <map> +#include "ns_npp_personality.h" + +typedef std::map<std::string, CNotificationpersistentservicePersonality *> Personality_Type; + +/** + * This class maintains information on creation of new personality or + * change of personality. + */ +class CnotificationpersistentservicePersonalizationManager { + private: + Personality_Type *m_pmPersonality; ///< list of personality + + UI_32 m_uiUserId; ///< unique user id + + std::string m_cCurrentPersonality; ///< current personality name + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CreatePersonality + /// This function is used to create new Personality. + /// + /// \param [IN] f_cpersonalityname + /// std::string - Personality name + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus CreatePersonality(const std::string &f_cpersonalityname); + + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CnotificationpersistentservicePersonalizationManager + /// Constructor of CnotificationpersistentservicePersonalizationManager class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CnotificationpersistentservicePersonalizationManager(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CnotificationpersistentservicePersonalizationManager + /// Destructor of CnotificationpersistentservicePersonalizationManager class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CnotificationpersistentservicePersonalizationManager(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceGetPersonality + /// This function is used to get the current personality. + /// + /// \param [OUT] f_cpersonalityname + /// std::string - Personality name + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceGetPersonality(std::string &f_cpersonalityname); // NOLINT (runtime/references) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceSetPersonality + /// This function is used to set the new personality. + /// + /// \param [IN] f_cpersonalityname + /// std::string - Personality name + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus NotificationpersistentserviceSetPersonality(const std::string f_cpersonalityname); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// NotificationpersistentserviceIsValidPersonality + /// Check if user is valid or not. + /// + /// \param [IN] f_cpersonalityname + /// std::string - Personality name + /// + /// \return BOOL + /// TRUE - Valid user + /// FALSE - Not a valid user + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + BOOL NotificationpersistentserviceIsValidPersonality(const std::string f_cpersonalityname); +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PERSONALIZATION_MANAGER_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_profiling_protocols_internal.h b/nsframework/notification_persistent_service/server/include/ns_npp_profiling_protocols_internal.h new file mode 100644 index 00000000..13b96a23 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_profiling_protocols_internal.h @@ -0,0 +1,34 @@ +/* + * @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_NativeServices +/// \brief This file contains declaration of all the protocols and structures related to profiling. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PROFILING_PROTOCOLS_INTERNAL_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PROFILING_PROTOCOLS_INTERNAL_H_ + + +#define NPS_PROFILE_NOTIFICATION_REQ 0x1AA +#define NPS_PROFILE_NOTIFICATION_RESP 0x1BB + +#define NPS_PROFILE_PERSISTENCE_REQ 0x2AA +#define NPS_PROFILE_PERSISTENCE_RESP 0x2BB + + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_PROFILING_PROTOCOLS_INTERNAL_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_registry_entry.h b/nsframework/notification_persistent_service/server/include/ns_npp_registry_entry.h new file mode 100644 index 00000000..3cb475ee --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_registry_entry.h @@ -0,0 +1,330 @@ +/* + * @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. +/// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_REGISTRY_ENTRY_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_REGISTRY_ENTRY_H_ + +#include <native_service/frameworkunified_types.h> +#include <string> +#include "ns_npp_types.h" + +/** + * This class contains the registry information of the files/folders to be peresisted. + */ +class CRegistryEntry { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CRegistryEntry + /// Constructor of CRegistryEntry class + /// + /// \param [OUT] f_ctag + /// std::string& - File or Folder tag + /// + /// \param [OUT] f_crequester + /// std::string& - Requester Name + /// + /// \param [OUT] f_cstoragepath + /// std::string& - File or Folder persistence storage path + /// + /// \param [IN] f_bisuserpersistence + /// BOOL - File or Folder is user specific + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + explicit CRegistryEntry(const std::string &f_ctag, const std::string &f_crequester, + const std::string &f_cstoragepath, BOOL f_bisuserpersistence); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CRegistryEntry + /// Copy Constructor of CRegistryEntry class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CRegistryEntry(const CRegistryEntry &f_objin); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// operator= + /// Operator overload = + /// + /// \param [IN] f_objin + /// CRegistryEntry& - In object. + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CRegistryEntry &operator=(const CRegistryEntry &f_objin); // NOLINT (readability/naming) + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetReleasePath + /// Set release path. + /// + /// \param [IN] f_creleasepath + /// std::string& - Path of the file/folder to be released. + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + VOID SetReleasePath(const std::string &f_creleasepath); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetBeingPersisted + /// Set the file/folder persist member variable to true to notify that the file/folder is being + /// persisted. + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + VOID SetBeingPersisted(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// AckReceived + /// Ack from copy worker received. Process the ack. + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + VOID AckReceived(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// IsReleased + /// Check if File/folder released or not. + /// + /// \param + /// + /// \return BOOL + // BOOL - True if file/folder is released else false + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + BOOL IsReleased() const; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// HasntBeenPersisted + /// File persisted or not + /// + /// \param + /// + /// \return BOOL + // BOOL - True if file is not persisted else false + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + BOOL HasntBeenPersisted() const; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// IsPersisted + /// File/Folder persisted or not + /// + /// \param + /// + /// \return BOOL + // BOOL - True if file/folder is persisted else false + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + BOOL IsPersisted() const; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// IsAckPending + /// Ack is pending or not. + /// + /// \param + /// + /// \return BOOL + // BOOL - True if ack is pending else false + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + BOOL IsAckPending() const; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetPersistPath + /// Get the persist path. + /// + /// \param + /// + /// \return std::string + // std::string - Returns the persist path. + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + std::string GetPersistPath() const; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetReleasePath + /// Get the release path. + /// + /// \param + /// + /// \return std::string + // std::string - Returns the release path. + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + std::string GetReleasePath() const; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetLoadPath + /// Get the load path. + /// + /// \param [IN] f_epersisttype + /// ENotificationpersistentservicePersistType - type of persisted data + /// + /// \param [IN] f_cusername + /// std::string - Current user name + /// + /// + /// \return std::string + // std::string - Returns the load path. + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + std::string GetLoadPath(ENotificationpersistentservicePersistType f_epersisttype, std::string f_cusername) const; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetRequester + /// Get the name of requester. + /// + /// \param + /// + /// \return std::string + // std::string - Returns the name of requester. + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + std::string GetRequester() const; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetTag + /// Get the tag. + /// + /// \param + /// + /// \return std::string + // std::string - Returns the tag. + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + std::string GetTag() const; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// IsUserPersistence + /// Returns TRUE if it is a user persistence. + /// + /// \param + /// + /// \return BOOL + // BOOL - Returns TRUE if it is a user persistence. + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + BOOL IsUserPersistence(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetCurrentAction + /// Set current copying action of a the corresponding tag. + /// + /// \param [IN] f_ecurrentaction + /// ENPS_Loadtype - Current action + /// + /// \return + //////////////////////////////////////////////////////////////////////////////////////////////// + VOID SetCurrentAction(ENPS_Loadtype f_ecurrentaction); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ResetPersistedFlag + /// Reset Persist flags + /// + /// \param + /// + /// \return + //////////////////////////////////////////////////////////////////////////////////////////////// + VOID ResetPersistedFlag(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetPersistProperties + /// creates persistence path and stores the persist type + /// + /// \param [IN] f_epersisttype + /// ENotificationpersistentservicePersistType - Set persist type + /// \param [IN] f_cusername + /// std::string - Username related to persist tag if any. + /// + /// + /// \return + //////////////////////////////////////////////////////////////////////////////////////////////// + VOID SetPersistProperties(ENotificationpersistentservicePersistType f_epersisttype, std::string f_cusername = ""); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetPersistType + /// Returns persist type of a job + /// + /// \param + /// + /// \return ENotificationpersistentservicePersistType + // ENotificationpersistentservicePersistType - Returns persist type + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ENotificationpersistentservicePersistType GetPersistType() const; + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetPersistentCategory + /// Sets the persistent type related to tag + /// + /// \param [IN] f_epersistcategory + /// EFrameworkunifiedPersistCategory - persist category + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus SetPersistentCategory(EFrameworkunifiedPersistCategory f_epersistcategory); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetPersistentCategory + /// Returns persistent type of tag + /// + /// \param + /// + /// \return EFrameworkunifiedPersistCategory + // EFrameworkunifiedPersistCategory - Returns persistent type + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedPersistCategory GetPersistentCategory(); + + ENPSPersistenceJobState m_eJobState; // Current state of a job + + private: + std::string m_cTag; // File/Folder tag + std::string m_cRequestor; // Requester application name + BOOL m_bIsReleased; // if file or folder released + BOOL m_bIsPersisted; // if file or folder is persisted + std::string m_cPersistPath; // Persist path + std::string m_cReleasePath; // Release path + std::string m_cBasePath; // Persist base path + BOOL m_bIsUserPersistence; // If user persistence + ENPS_Loadtype m_eCurrentAction; // Current action to load file to/from + /// temporary/persistence memory + ENotificationpersistentservicePersistType m_ePersistType; + EFrameworkunifiedPersistCategory m_ePersistCategory; // Persistent category +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_REGISTRY_ENTRY_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_regular_notification.h b/nsframework/notification_persistent_service/server/include/ns_npp_regular_notification.h new file mode 100644 index 00000000..da5427de --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_regular_notification.h @@ -0,0 +1,109 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains declaration of class CRegularNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_REGULAR_NOTIFICATION_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_REGULAR_NOTIFICATION_H_ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <string> +#include "ns_npp_notification.h" + +/** + * This class inherits CNotification class and implements regular notification related operations. + */ +class CRegularNotification : public CNotification { + private: + // no members in private + + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CRegularNotification + /// Constructor of CRegularNotification class + /// + /// \param [IN] f_cnotificationname + /// std::string - Notification name + /// + /// \param [IN] f_uimaxmsgsize + /// UI_32 - Maximum size of notification data + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CRegularNotification(const std::string &f_cnotificationname, + const UI_32 f_uimaxmsgsize); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CRegularNotification + /// Destructor of CRegularNotification class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CRegularNotification(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// AddEventReciever + /// This function adds the name of the application to receiver list of particular notification. + /// + /// \param [IN] f_csubscribername + /// std::string - name of application subscribing for notification + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus AddEventReciever(const std::string &f_csubscribername); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Publish + /// This function publishes the notification to subscribed clients. + /// + /// \param [IN] f_cservicename + /// std::string - name of service publishing the notification + /// + /// \param [IN] f_pmessage + /// std::string - data of notification + /// + /// \param [IN] f_uimsgsize + /// std::string - length of data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus Publish(const std::string &f_cservicename, + PVOID f_pmessage, + const UI_32 f_uimsgsize); +}; + + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_REGULAR_NOTIFICATION_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_state_nor_persistence_notification.h b/nsframework/notification_persistent_service/server/include/ns_npp_state_nor_persistence_notification.h new file mode 100644 index 00000000..26edf734 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_state_nor_persistence_notification.h @@ -0,0 +1,177 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains declaration of class CStateNorPersistenceNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_STATE_NOR_PERSISTENCE_NOTIFICATION_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_STATE_NOR_PERSISTENCE_NOTIFICATION_H_ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <string> +#include "ns_npp_state_notification.h" + +/** + * This class inherits CStateNotification class and implements specific operations related to + * nor persistent notifications. + */ +class CStateNorPersistenceNotification : public CStateNotification { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CStateNorPersistenceNotification + /// Constructor of CStateNorPersistenceNotification class + /// + /// \param [IN] f_cnotificationname + /// std::string - Notification name + /// + /// \param [IN] f_uimaxmsgsize + /// UI_32 - Maximum size of notification data + /// + /// \param [IN] f_uidelay + /// UI_32 - delay + /// + /// \param [IN] f_epersistcategory + /// EFrameworkunifiedPersistCategory - persist category + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CStateNorPersistenceNotification(const std::string &f_cnotificationname, + const UI_32 f_uimaxmsgsize, + const UI_32 f_uidelay, + const EFrameworkunifiedPersistCategory f_epersistcategory = eFrameworkunifiedUserData); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CStateNorPersistenceNotification + /// Destructor of CStateNorPersistenceNotification class + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CStateNorPersistenceNotification(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetPersistenceDelay + /// Method to get the persistence delay for a specific notification. + /// + /// \param + /// + /// \return UI_32 + // UI_32 - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + UI_32 GetPersistenceDelay(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Publish + /// This function publishes the notification to subscribed clients and saves the data + /// immediately to persistent memory. + /// + /// \param [IN] f_cservicename + /// std::string - name of service publishing the notification + /// + /// \param [IN] f_pmessage + /// std::string - data of notification + /// + /// \param [IN] f_uimsgsize + /// std::string - length of data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus Publish(const std::string &f_cservicename, + PVOID f_pmessage, + const UI_32 f_uimsgsize); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// PublishNotification + /// This function publishes the notification to subscribed clients. + /// + /// \param [IN] f_cservicename + /// std::string - name of service publishing the notification + /// + /// \param [IN] f_pmessage + /// std::string - data of notification + /// + /// \param [IN] f_uimsgsize + /// std::string - length of data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus PublishNotification(const std::string &f_cservicename, + PVOID f_pmessage, + const UI_32 f_uimsgsize); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetPersistentCategory + /// Gets the persist type of notification + /// + /// + /// \return EFrameworkunifiedPersistCategory + // EFrameworkunifiedPersistCategory - persist type + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedPersistCategory GetPersistentCategory(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetPersistentCategory + /// Sets the persist type of notification + /// + /// \param [IN] f_epersistcategory + /// EFrameworkunifiedPersistCategory - persist category + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus SetPersistentCategory(const EFrameworkunifiedPersistCategory f_epersistcategory); + // Handle of the immediate persistence worker thread. + static HANDLE m_hNSImmediatePersistenceThread; // NOLINT (readability/naming) + + private: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SaveDataToNor + /// Saves the persistent data to nor + /// + /// \param [IN] f_pmessage + /// PVOID - Message data + /// + /// \param [IN] f_msgsize + /// UI_32 - Size of Message data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus SaveDataToNor(PVOID f_pmessage, + const UI_32 f_msgsize); + + UI_32 m_uiDelay; // Time Delay between persistence on NOR + + EFrameworkunifiedPersistCategory m_ePersistCategory; // Persistent category +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_STATE_NOR_PERSISTENCE_NOTIFICATION_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_state_notification.h b/nsframework/notification_persistent_service/server/include/ns_npp_state_notification.h new file mode 100644 index 00000000..aaa69927 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_state_notification.h @@ -0,0 +1,221 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains declaration of class CStateNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_STATE_NOTIFICATION_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_STATE_NOTIFICATION_H_ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <string> +#include "ns_npp_notification.h" + +class CPersistentData; + +/** + * This class inherits CNotification class and implements state and persistent notification + * related operations. + */ +class CStateNotification : public CNotification { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CStateNotification + /// Constructor of CStateNotification class + /// + /// \param [IN] f_cnotificationname + /// std::string - Notification name + /// + /// \param [IN] f_uimaxmsgsize + /// UI_32 - Maximum size of notification data + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CStateNotification(const std::string &f_cnotificationname, + const UI_32 f_uimaxmsgsize); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CStateNotification + /// Destructor of CStateNotification class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual ~CStateNotification(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// AddEventReciever + /// This function adds the name of the application to receiver list of particular notification. + /// + /// \param [IN] f_csubscribername + /// std::string - name of application subscribing for notification + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus AddEventReciever(const std::string &f_csubscribername); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// Publish + /// This function publishes the notification to subscribed clients. + /// + /// \param [IN] f_cservicename + /// std::string - name of service publishing the notification + /// + /// \param [IN] f_pmessage + /// std::string - data of notification + /// + /// \param [IN] f_uimsgsize + /// std::string - length of data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus Publish(const std::string &f_cservicename, + PVOID f_pmessage, + const UI_32 f_uimsgsize); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetPersistentData + /// This function get the data related to notification + /// + /// \param + /// + /// \return CPersistentData + // CPersistentData - notification data + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + const CPersistentData *GetPersistentData(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetPersistentData + /// This function is used to set the data related to notification + /// + /// \param [IN] f_pmessage + /// PVOID - Message data + /// + /// \param [IN] f_msgsize + /// UI_32 - Size of Message data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus SetPersistentData(PVOID f_pmessage, + const UI_32 f_msgsize); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetDefaultPersistentData + /// This function get the default data(if any) related to notification + /// + /// \param + /// + /// \return CPersistentData + // CPersistentData - notification data + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + const CPersistentData *GetDefaultPersistentData(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetDefaultPersistentData + /// This function is used to set the default data related to notification + /// + /// \param [IN] f_pmessage + /// PVOID - Message data + /// + /// \param [IN] f_msgsize + /// UI_32 - Size of Message data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + virtual EFrameworkunifiedStatus SetDefaultPersistentData(PVOID f_pmessage, + const UI_32 f_msgsize); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// IsPublished + /// This functions returns the published status of notification. + /// + /// \param + /// + /// \return BOOL + // BOOL - returns true if published before + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + BOOL IsPublished(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ResetMaxMessageSize + /// This function reset the max size of data that can be published with notification. + /// Also deletes the old persistent data and default data. + /// + /// \param [IN] f_uilength + /// std::string - Max size for notification data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus ResetMaxMessageSize(const UI_32 f_uilength); + + protected: + CPersistentData *m_pData; ///< persistent data of notification + + CPersistentData *m_pDefaultData; ///< persistent data of notification + + BOOL m_bWasPublished; ///< Flag to check whether publisher had published notification + + private: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetData + /// This function is used to set the persistent data + /// + /// \param [IN] f_pdata + /// CPersistentData - persistent data ptr + /// + /// \param [IN] f_pmessage + /// PVOID - Message data + /// + /// \param [IN] f_msgsize + /// UI_32 - Size of Message data + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus SetData(CPersistentData *f_pdata, + PVOID f_pmessage, + const UI_32 f_msgsize); +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_STATE_NOTIFICATION_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_state_persistence_notification.h b/nsframework/notification_persistent_service/server/include/ns_npp_state_persistence_notification.h new file mode 100644 index 00000000..1123941c --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_state_persistence_notification.h @@ -0,0 +1,104 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains declaration of class CStatePersistenceNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_STATE_PERSISTENCE_NOTIFICATION_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_STATE_PERSISTENCE_NOTIFICATION_H_ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#include <string> +#include "ns_npp_state_notification.h" + +/** + * This class inherits CStateNotification class and implements specific operations related to + * persistent notifications. + */ +class CStatePersistenceNotification : public CStateNotification { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CStatePersistenceNotification + /// Constructor of CStatePersistenceNotification class + /// + /// \param [IN] f_cnotificationname + /// std::string - Notification name + /// + /// \param [IN] f_uimaxmsgsize + /// UI_32 - Maximum size of notification data + /// + /// \param [IN] f_epersistcategory + /// EFrameworkunifiedPersistCategory - persist category + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CStatePersistenceNotification(const std::string &f_cnotificationname, + const UI_32 f_uimaxmsgsize, + const EFrameworkunifiedPersistCategory f_epersistcategory = eFrameworkunifiedUserData); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CStatePersistenceNotification + /// Destructor of CStatePersistenceNotification class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CStatePersistenceNotification(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// GetPersistentCategory + /// Gets the persist type of notification + /// + /// + /// \return EFrameworkunifiedPersistCategory + // EFrameworkunifiedPersistCategory - persist type + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedPersistCategory GetPersistentCategory(); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// SetPersistentCategory + /// Sets the persist type of notification + /// + /// \param [IN] f_epersistcategory + /// EFrameworkunifiedPersistCategory - persist category + /// + /// \return EFrameworkunifiedStatus + // EFrameworkunifiedStatus - success or failure status + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + EFrameworkunifiedStatus SetPersistentCategory(const EFrameworkunifiedPersistCategory f_epersistcategory); + + private: + EFrameworkunifiedPersistCategory m_ePersistCategory; // Persistent category +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_STATE_PERSISTENCE_NOTIFICATION_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_state_persistence_user_notification.h b/nsframework/notification_persistent_service/server/include/ns_npp_state_persistence_user_notification.h new file mode 100644 index 00000000..8423e3e9 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_state_persistence_user_notification.h @@ -0,0 +1,73 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains declaration of class CStatePersistenceUserNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_STATE_PERSISTENCE_USER_NOTIFICATION_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_STATE_PERSISTENCE_USER_NOTIFICATION_H_ + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <string> +#include "ns_npp_state_notification.h" + + +/** + * This class inherits CStateNotification class and implements specific operations related to + * persistent notifications specific to user. + */ +class CStatePersistenceUserNotification : public CStateNotification { + public: + //////////////////////////////////////////////////////////////////////////////////////////////// + /// CStatePersistenceUserNotification + /// Constructor of CStatePersistenceUserNotification class + /// + /// \param [IN] f_cnotificationname + /// std::string - Notification name + /// + /// \param [IN] f_uimaxmsgsize + /// UI_32 - Maximum size of notification data + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + CStatePersistenceUserNotification(const std::string &f_cnotificationname, + const UI_32 f_uimaxmsgsize); + + //////////////////////////////////////////////////////////////////////////////////////////////// + /// ~CStatePersistenceUserNotification + /// Destructor of CStatePersistenceUserNotification class + /// + /// \param + /// + /// \return + /// + //////////////////////////////////////////////////////////////////////////////////////////////// + ~CStatePersistenceUserNotification(); +}; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_STATE_PERSISTENCE_USER_NOTIFICATION_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_threads.h b/nsframework/notification_persistent_service/server/include/ns_npp_threads.h new file mode 100644 index 00000000..042e8579 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_threads.h @@ -0,0 +1,46 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief +/// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_THREADS_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_THREADS_H_ + +// name of threads +#define NS_NPP_READ_THREAD_NAME "NS_NPPReadWkr" +#define NS_NPP_WRITE_THREAD_NAME "NS_NPPWriteWkr" +#define NS_NPP_IMMEDIATE_PERSIST_THREAD_NAME "NS_NPPIPWkr" +#define NS_NPP_DATA_RESET_THREAD_NAME "NS_NPPDataRst" + +// priority of threads +#define NS_NPP_READ_THREAD_PRIO 15 +#define NS_NPP_WRITE_THREAD_PRIO 15 +#define NS_NPP_IMMEDIATE_PERSIST_THREAD_PRIO 25 +#define NS_NPP_DATA_RESET_THREAD_PRIO 10 + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_THREADS_H_ diff --git a/nsframework/notification_persistent_service/server/include/ns_npp_types.h b/nsframework/notification_persistent_service/server/include/ns_npp_types.h new file mode 100644 index 00000000..79a44d74 --- /dev/null +++ b/nsframework/notification_persistent_service/server/include/ns_npp_types.h @@ -0,0 +1,212 @@ +/* + * @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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief +/// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_TYPES_H_ +#define NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_TYPES_H_ + +#include <native_service/frameworkunified_sm_eventdata.h> +#include <aglpath.h> +#include <native_service/ns_np_types.h> + +// name of notification file to be saved in persistent memory depending on the persistent type category + +#define NOTIFICATIONFILE "PERSISTENT_NOTIFICATION" // stores user notification common to all user +#define USERNOTIFICATIONFILE "USER_PERSISTENT_NOTIFICATION" // stores user notification specific to particular user +#define FACTORYNOTIFICATIONFILE "FACTORY_NOTIFICATION" // stores factory notification +#define FACTORYCUSTOMERNOTIFICATIONFILE "FACTORYCUSTOMER_NOTIFICATION" // stores factorycustomer notification +#define DEALERNOTIFICATIONFILE "DEALER_NOTIFICATION" // stores dealer notification + +// name of persistence folder for persistent type categorization +#define USERDATA "UserData" // name of folder contatining userdata +#define FACTORYDATA "FactoryData" // name of folder contatining factory data +#define FACTORYCUSTOMERDATA "FactoryCustomerData" // name of folder contatining factory customer data +#define DEALERDATA "DealerData" // name of folder contatining dealer data + +// default user name for personalization +#define DEFAULTUSERNAME "DefaultUser" + +// name of NSNPS version file +#define VERSION_TXT "version.txt" + +#define STORAGE_PATH "/nv/BS/ns/npp/rwdata/" + + +typedef enum ENPSLoadType { + LOADTYPE_NONE = -1, + LOADTYPE_RELEASE = 0, // load file to persistent memory + LOADTYPE_LOAD = 1, // load file to temporary memory + LOADTYPE_RELOAD = 2, // reload the file. +} ENPS_Loadtype; + +/// \typedef ENotificationpersistentservicePersistType +/// \brief Persist file types +typedef enum ENotificationpersistentservicePersistType { + ENOTIFICATIONPERSISTENTSERVICEPERSISTFIRST = 0, ///< Add values after this value only. + ENOTIFICATIONPERSISTENTSERVICEPERSISTFILE, ///< Persist a file to a persistent memory + ENOTIFICATIONPERSISTENTSERVICEPERSISTFOLDER, ///< Persist a folder to a persistent memory + ENOTIFICATIONPERSISTENTSERVICEPERSISTNONE, ///< no type + ENOTIFICATIONPERSISTENTSERVICEPERSISTLAST, ///< Add values before this value only. +} ENotificationpersistentservicePersistType; + +typedef enum ENPSPersistenceJobState { + ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATEIDLE = 0, ///< Job is idle. // NOLINT (readability/naming) + ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATEINPROCESS = 1, ///< Job is in process. Either release or load. // NOLINT (readability/naming) + ENOTIFICATIONPERSISTENTSERVICEPERSISTJObSTATERELEASEABORTED = 2, ///< Job release was aborted due to abort shutdown. // NOLINT (readability/naming) +} ENPSPersistenceJobState; + +typedef CHAR CopyInfoStr[MAX_PATH_LENGTH]; ///< Information passed via the framework + + +typedef enum ENPSCopyWorkerProtocol { + // > Command(s) + CP_WRK_CMD_START = 1500, + CP_WRK_CMD_STOP = 1501, + CP_WRK_CMD_COPY = 1502, + CP_WRK_CMD_RESUME = 1503, // This will release the thread from the abort command. + + // < Command Ack(s) + CP_WRK_ACK_CMD_COMPLETE = 1504, + + // < Notification(s) + CP_WRK_NTFY = 1505, + + // < Shutdown request command + CMD_WRK_SHUTDOWN_REQ = 1506, + CMD_WRK_SHUTDOWN_ACK = 1507, + + CMD_DELETE_OLD_DATA = 1508, + + AR_CMD_START = 1400, + AR_CMD_STOP = 1401, + AR_CMD_ARCHIVE = 1402, + AR_CMD_RESUME = 1403, // This will release the thread from the abort command. + + // < Command Ack(s) + AR_ACK_CMD_COMPLETE = 1404, + + // < Notification(s) + AR_CMD_NTFY = 1405, + + NOR_PERSISTENCE_TIMER_START = 1406, + NOR_PERSISTENCE_REGISTER = 1407, + NOR_PERSISTENCE_UNREGISTER = 1408, + // this cmd is used to tell the NOR thread to stop the timer + // for all the the notifications in case of userdata reset during shutdown + NOR_PERSISTENCE_ONSHUTDOWN = 1409, + // while to persist the data immediately irrespective of delay in case of shutdown without userdata reset. + // ack sent to NPPService main thread by Nor worker thread after persisting immediate data + NOR_PERSISTENCE_ONSHUTDOWN_ACK = 1410, + // message sent by main thread to immediate persistence thread + // to change the persistent category of immediate notification + NOR_PERSISTENCE_CHANGE_CATEGORY = 1411 +} ENSP_CopyWorkerProtocol, *PENSP_CopyWorkerProtocol, ENPS_ArchiveProtocol; + + +typedef enum ENPSCopyWorkerFailures { + // > Failure codes(s) + CP_WRK_FAILURE_SRC_NOT_FND = 3500, + CP_WRK_FAILURE_DST_CREATE = 3501, + CP_WRK_FAILURE_ABORT_DURING_CP = 3502, + CP_WRK_FAILURE_ABORT_BEFORE_CP = 3503, + CP_WRK_FAILURE_WRITE_ERROR_CP = 3504, + + AR_THREAD_FAILURE_SRC_NOT_FND = 3400, + AR_THREAD_FAILURE_DST_CREATE = 3401, + AR_THREAD_FAILURE_ABORT_DURING_ARCHIVE = 3402, + AR_THREAD_FAILURE_ABORT_BEFORE_ARCHIVE = 3403, +} ENPS_CopyWorkerFailures, *PENPS_CopyWorkerFailures, ENPS_ArchiveFailures; + +typedef struct NPSCopyAckMsg { + ENSP_CopyWorkerProtocol m_eworkerprotocol; // Worker Load or Release Protocol Id +} NSP_CopyAckMsg; + +typedef enum NotificationpersistentserviceCompressionType { + ENOTIFICATIONPERSISTENTSERVICENONE = 0, /// No Compression before file persistence + ENOTIFICATIONPERSISTENTSERVICEDEFAULTCOMPRESSION, /// Compress file before persistence using default compression method + ENOTIFICATIONPERSISTENTSERVICECOMPRESSUSINGLIBZ /// Compress file before persistence using libz +} NOTIFICATIONPERSISTENTSERVICE_COMPRESSION_TYPE; + +typedef struct NPSCopyInfoMsg { + CopyInfoStr m_csourcepath; // Source path + CopyInfoStr m_cdestinationpath; // Destination path + CopyInfoStr m_cpersistenttag; // Tag for Persistence + CopyInfoStr m_crequesterappname; // Requester Name + ENPS_Loadtype m_eloadtype; // Load to Persistent or Temporary Memory + ENotificationpersistentservicePersistType m_epersisttype; // Folder or File Persistence + NOTIFICATIONPERSISTENTSERVICE_COMPRESSION_TYPE m_ecompressiontype; // Check for Compression of the file +} NSP_CopyInfoCmd; + +typedef struct NPSCopyStatus { + BOOL m_bpersistencechk; // Persistence Success or Failure + ENPS_CopyWorkerFailures m_ecopyfailures; // Failure Protocol ID + CopyInfoStr m_cpersistenttag; // Tag for Persistence + CopyInfoStr m_crequesterappname; // Requester Name + ENPS_Loadtype m_eloadtype; // Load to Persistent or Temporary Memory + ENotificationpersistentservicePersistType m_epersisttype; // Folder or File Persistence + NOTIFICATIONPERSISTENTSERVICE_COMPRESSION_TYPE m_ecompressiontype; // Check for Compression of the file +} NSP_CopyStatusResponse, NSP_CopyCancel; + + +// Structure for Nor Persistent Notification +typedef struct TNorPersistenceNotifInfoHeader { + CHAR m_cnotificationname[MAX_STRING_SIZE_NOTIFICATION]; ///< Name of Notification + UI_32 m_uimaxmsglength; ///< Maximum data length of notification + EFrameworkunifiedNotificationType m_epersistenttype; ///< type of notification + CHAR m_cpublishername[MAX_NAME_SIZE_APP]; ///< Service Name + UI_32 m_uimsgsize; ///< length of message + UI_32 m_uidelay; ///< Time delay between persistence + EFrameworkunifiedPersistCategory m_epersistcategory; ///< Persistent Category +} TNorPersistenceNotifInfoHeader; + +typedef struct _TImmediatePersistenceRegisterNotifInfo { // NOLINT (readability/naming) + CHAR m_cnotificationname[MAX_STRING_SIZE_NOTIFICATION]; ///< Name of Notification + UI_32 m_uidelay; ///< Time delay between persistence + EFrameworkunifiedPersistCategory m_epersistcategory; ///< Persistent Category +} TImmediatePersistenceRegisterNotifInfo; + +typedef struct _TImmediatePersistenceUnregisterNotifInfo { // NOLINT (readability/naming) + CHAR m_cnotificationname[MAX_STRING_SIZE_NOTIFICATION]; ///< Name of Notification +} TImmediatePersistenceUnregisterNotifInfo; + +typedef struct _NPS_CopyShutdown { // NOLINT (readability/naming) + CopyInfoStr m_crequesterappname; +} NSP_CopyShutdown, NSP_CopyShutdownAck; + +typedef struct _TImmediatePersistenceChangeCategory { // NOLINT (readability/naming) + TNorPersistenceNotifInfoHeader m_tnornotifInfoheader; ///< Notification info with new persist category type + EFrameworkunifiedPersistCategory m_eoldpersistcategory; ///< Old Persistent Category of notification +} TImmediatePersistenceChangeCategory; + +typedef struct _TImmediateShutdown { // NOLINT (readability/naming) + EFrameworkunifiedShutdownType f_eshutdowntype; + UI_32 f_uinotificationpersistentservicepersistcategoryflag; +} TImmediateShutdown; + +#endif // NOTIFICATION_PERSISTENT_SERVICE_SERVER_INCLUDE_NS_NPP_TYPES_H_ diff --git a/nsframework/notification_persistent_service/server/src/app_states.cpp b/nsframework/notification_persistent_service/server/src/app_states.cpp new file mode 100644 index 00000000..c54508b1 --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of internal transitions of state machine +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#include <unistd.h> +#include <native_service/ns_np_service.h> +#include <native_service/frameworkunified_framework_if.h> +#include <native_service/ns_np_service_protocol.h> +#include <native_service/ns_np_service_notification.h> +#include <string> +#include <vector> +#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 <ns_npp_profiling_protocols_internal.h> +#endif + +#ifdef AGL_STUB +#include <other_service/strlcpy.h> +#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<CNSNPP *>(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<CHAR> l_vData = std::vector<CHAR>(l_uiMsgLength); + + // get the received data + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize( + l_pHApp, &l_vData[0], static_cast<UI_32>(l_vData.size()), eSMRRelease))) { + l_pMsg = reinterpret_cast<NC_register_multiple_notif_msg *>(&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<CNSNPP *>(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<PVOID>(&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<CNSNPP *>(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<CHAR> l_vData = std::vector<CHAR>(l_uiMsgLength); + + // get the data received + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &l_vData[0], static_cast<UI_32>(l_vData.size()), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + l_pMsg = reinterpret_cast<NC_subscribe_multiple_notif_msg *>(&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<CNSNPP *>(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<CHAR> pMsgData = std::vector<CHAR>(l_uiMsgLength); + + // get the received data + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &pMsgData[0], static_cast<UI_32>(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<CNSNPP *>(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<PVOID>(&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<CNSNPP *>(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<CHAR> l_vData = std::vector<CHAR>(l_uiMsgLength); + + // get the data received + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &l_vData[0], static_cast<UI_32>(l_vData.size()), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + l_pMsg = reinterpret_cast<NC_unsubscribe_multiple_notif_msg *>(&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<CNSNPP *>(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::vector<CHAR>l_vData = std::vector<CHAR>(l_uiMsgLength); + + // get the received data + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &l_vData[0], static_cast<UI_32>(l_vData.size()), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + l_pMsg = reinterpret_cast<NC_unregister_multiple_notif_msg *>(&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<CNSNPP *>(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<PVOID>(&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<CNSNPP *>(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<CHAR> pMsgData = std::vector<CHAR>(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<CNSNPP *>(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<CNSNPP *>(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<long int>(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<PVOID>(&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<CNSNPP *>(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<CNSNPP *>(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<CNSNPP *>(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<CNSNPP *>(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<CNSNPP *>(l_pNotificationpersistentserviceHSM); + + if (NULL != l_pnsnpp) { // LCOV_EXCL_BR_LINE 6: can't be NULL + CShutDownMsgData *l_pMsgData = dynamic_cast<CShutDownMsgData *>(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<CNSNPP *>(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<CNSNPP *>(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<PVOID>(&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<CNSNPP *>(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<PVOID>(&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<CNSNPP *>(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<PVOID>(&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<CNSNPP *>(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<PVOID>(&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<CNSNPP *>(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<PVOID>(&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<CNSNPP *>(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<PVOID>(&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<CNSNPP *>(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<CHAR> l_vData = std::vector<CHAR>(l_uiMsgLength); + + // get the received data + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &l_vData[0], static_cast<UI_32>(l_vData.size()), eSMRRelease))) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT[whitespace/line_length] + l_pMsg = reinterpret_cast<NC_register_multiple_immediate_notif_msg *>(&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<CNSNPP *>(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<CNSNPP *>(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<CHAR> pMsgData = std::vector<CHAR>(l_uiMsgLength); + + // get the received data + if (eFrameworkunifiedStatusOK == (l_estatus = FrameworkunifiedGetMsgDataOfSize(l_pHApp, &pMsgData[0], static_cast<UI_32>(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<CNSNPP *>(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<CNSNPP *>(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<PVOID>(&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<CNSNPP *>(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<PVOID>(&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<PVOID>(&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<CNSNPP *>(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<PVOID>(&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<CNSNPP *>(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<CNSNPP *>(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/nsframework/notification_persistent_service/server/src/notificationpersistentservice_application.cpp b/nsframework/notification_persistent_service/server/src/notificationpersistentservice_application.cpp new file mode 100644 index 00000000..c1b97f96 --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief +/// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <native_service/frameworkunified_application.h> +#include <native_service/frameworkunified_framework_if.h> +#include <native_service/ns_np_service_protocol.h> +#include <native_service/ns_np_service_notification.h> + +#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<UI_32>(_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/nsframework/notification_persistent_service/server/src/notificationpersistentservice_main.cpp b/nsframework/notification_persistent_service/server/src/notificationpersistentservice_main.cpp new file mode 100644 index 00000000..fd963c5f --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief +/// +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <native_service/ns_version.h> +#include <native_service/ns_version_if.h> +#include <native_service/frameworkunified_dispatcher.h> +#include <native_service/frameworkunified_framework_if.h> + +#include <stdlib.h> +#include <cstdlib> +#include <iostream> + +#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<SI_32>(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<UI_16>(l_iTmpArgValue); + break; + } + + default: + l_estatus = eFrameworkunifiedStatusFail; + break; + } + return l_estatus; +} diff --git a/nsframework/notification_persistent_service/server/src/ns_npp.cpp b/nsframework/notification_persistent_service/server/src/ns_npp.cpp new file mode 100644 index 00000000..25b64432 --- /dev/null +++ b/nsframework/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 <time.h> +#include <errno.h> +#include <fcntl.h> +#include <stdlib.h> +#include <dirent.h> +#include <sys/stat.h> +#include <sys/timeb.h> +#include <sys/types.h> + +#include <native_service/frameworkunified_sm_leafstate.h> +#include <native_service/frameworkunified_multithreading.h> +#include <native_service/ns_np_service_protocol.h> + +#include <string> +#include <vector> + +#include <native_service/ns_np_service_nor_persistence_internal.h> +#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<CNotificationsToPersist *> 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<UI_32>(_countof(ns_npp_internal_protocol_handlers)))) + || (eFrameworkunifiedStatusOK != FrameworkunifiedAttachHSMEventsToDispatcher( + f_happ, m_cReadThreadName.c_str(), + ns_npp_internal_protocol_handlers, + static_cast<UI_32>(_countof(ns_npp_internal_protocol_handlers)))) + || (eFrameworkunifiedStatusOK != FrameworkunifiedAttachHSMEventsToDispatcher( + f_happ, m_cImmediatePersistenceThreadName.c_str(), + immediate_thread_protocol_handlers, + static_cast<UI_32>(_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<UI_8>(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<UI_8>(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<UI_32>(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/nsframework/notification_persistent_service/server/src/ns_npp_archive.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_archive.cpp new file mode 100644 index 00000000..b54faebd --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \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 <other_service/strlcpy.h> +#endif + +#include <stdio.h> +#include <errno.h> +#include <unistd.h> +#include <fcntl.h> +#include <zlib.h> +#include <dirent.h> +#include <zconf.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <libtar_listhash.h> +#include <string> +#include <utility> +#include <vector> + +#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<PCHAR >(f_pctarfiledestpath.c_str()); + PCHAR l_pcRootDirPath = const_cast<PCHAR >(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<PCHAR >(f_pcrootdirpath.c_str()); + PCHAR l_pcTarFileDestPath = const_cast<PCHAR >(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<UI_32>(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<UI_32>(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<uInt>(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<uInt>(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/nsframework/notification_persistent_service/server/src/ns_npp_binary_accesser.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_binary_accesser.cpp new file mode 100644 index 00000000..e0a749f7 --- /dev/null +++ b/nsframework/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 <sys/stat.h> +#include <sys/types.h> +#include <unistd.h> +#include <fcntl.h> +#ifdef AGL_STUB +#include <other_service/strlcpy.h> +#endif +#include <cerrno> +#include <string> +#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<long int>(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<size_t>(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<UI_32>(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<UI_32>(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<UI_32>(sizeof(CPersistDataHeader)); + if (static_cast<int>(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<long>(sizeof(PersistFileHeder))) { // NOLINT (runtime/int) + size_t body_size = static_cast<size_t>(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<ssize_t>(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<UI_32>(CalcCRC(buf, static_cast<UI_32>(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<ssize_t>(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<long>(sizeof(PersistFileHeder))) { // NOLINT (runtime/int) + size_t body_size = static_cast<size_t>(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<ssize_t>(body_size)) { + UI_32 crc32 = static_cast<UI_32>(CalcCRC(buf, static_cast<UI_32>(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<UI_32>(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/nsframework/notification_persistent_service/server/src/ns_npp_copy_worker.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_copy_worker.cpp new file mode 100644 index 00000000..4638a7d4 --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file implements the CCopyWorker class. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <native_service/ns_util_crc.h> +#include <native_service/ns_logger_if.h> + +// standard headers +#include <sys/types.h> +#include <sys/stat.h> +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> +#include <fcntl.h> +#include <dirent.h> + +#include <string> +#include <utility> + +// 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 <other_service/strlcpy.h> +/*#include "PosixBasedOS001legacy_types.h"*/ +#include <unistd.h> +#include <sys/syscall.h> +#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 <typename C, eFrameworkunifiedStatus(C::*M)(HANDLE)> EFrameworkunifiedStatus WorkerCallback(HANDLE hthread) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + C *l_pClass = static_cast<C *>(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<CCopyWorker, &CCopyWorker::OnWrkCmdCopy> }, + { CP_WRK_CMD_RESUME, WorkerCallback<CCopyWorker, &CCopyWorker::OnWrkCmdResume> }, + { AR_CMD_ARCHIVE, WorkerCallback<CCopyWorker, &CCopyWorker::OnWrkCmdArchive> }, + { CMD_WRK_SHUTDOWN_REQ, WorkerCallback<CCopyWorker, &CCopyWorker::OnCmdShutdownRequest>}, +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// 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<long int>(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<UI_32>(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<long int>(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<UI_32>(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<UI_32>(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<long int>(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<long int>(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<UI_32>(_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<CCopyWorker *>(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/nsframework/notification_persistent_service/server/src/ns_npp_fs_directory.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_fs_directory.cpp new file mode 100644 index 00000000..8f4f98a0 --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains the implementation for class CFSDirectory. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef AGL_STUB +#include <other_service/PosixBasedOS001TimeApi.h> +#endif + +#include <stdio.h> +#include <dirent.h> +#include <errno.h> +#include <fcntl.h> +#include <sys/types.h> +#include <sys/stat.h> + +#ifdef AGL_STUB +#include <cstring> +#endif +#include <string> + +#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<PSTR >(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/nsframework/notification_persistent_service/server/src/ns_npp_handlelist.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_handlelist.cpp new file mode 100644 index 00000000..c9e88a8c --- /dev/null +++ b/nsframework/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 <utility> +#include <string> +#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/nsframework/notification_persistent_service/server/src/ns_npp_nor_persistence_worker_thread.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_nor_persistence_worker_thread.cpp new file mode 100644 index 00000000..d4b1604f --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \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 <native_service/ns_timer_if.hpp> +#include <native_service/ns_np_service_if.h> +#include <native_service/ns_utility_sys.hpp> +#include <native_service/frameworkunified_framework_if.h> +#include <native_service/frameworkunified_multithreading.h> +#include <native_service/frameworkunified_service_protocol.h> +#include <native_service/ns_np_service_protocol.h> +#include <native_service/ns_np_service_nor_persistence.h> + + +#include <sys/types.h> +#include <sys/stat.h> +#include <boost/bind.hpp> +#include <map> +#include <utility> +#include <string> + +#include <native_service/ns_np_service_nor_persistence_internal.h> +#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<NotificationName, CTimerHelper *> 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 <typename C, eFrameworkunifiedStatus(C::*M)(HANDLE)> EFrameworkunifiedStatus NorWorkerCallback(HANDLE hthread) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + + C *l_pClass = static_cast<C *>(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<CNorPersistenceWorker, + &CNorPersistenceWorker::OnNorPersistenceTimerStart>}, + { NOR_PERSISTENCE_REGISTER, NorWorkerCallback<CNorPersistenceWorker, + &CNorPersistenceWorker::RegisterImmediatePersistNotification>}, + { NOR_PERSISTENCE_UNREGISTER, NorWorkerCallback<CNorPersistenceWorker, + &CNorPersistenceWorker::UnregisterImmediatePersistNotification>}, + { NOR_PERSISTENCE_ONSHUTDOWN, NorWorkerCallback<CNorPersistenceWorker, + &CNorPersistenceWorker::OnShutdown>}, + { NOR_PERSISTENCE_CHANGE_CATEGORY, NorWorkerCallback<CNorPersistenceWorker, + &CNorPersistenceWorker::OnCategoryChange>} +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// 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<UI_32>(_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<CNorPersistenceWorker *>(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<TNorPersistenceNotifInfoHeader *>(static_cast<PVOID>(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<UI_16>(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<long int>(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<long int>(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<TNorPersistenceNotifInfoHeader *> + (static_cast<PVOID>(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<TImmediatePersistenceChangeCategory *>(static_cast<PVOID>(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<TNorPersistenceNotifInfoHeader *>(static_cast<PVOID>(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<PVOID>(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<TNorPersistenceNotifInfoHeader *>(static_cast<PVOID>(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<PVOID>(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/nsframework/notification_persistent_service/server/src/ns_npp_notification.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_notification.cpp new file mode 100644 index 00000000..8e2bb2d6 --- /dev/null +++ b/nsframework/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 <native_service/frameworkunified_framework_if.h> +#include <native_service/ns_message_center_if.h> +#include <native_service/ns_np_service_protocol.h> +#include <utility> +#include <iostream> +#include <string> +#include <native_service/ns_mc_system_info.h> +#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<PSTR>(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/nsframework/notification_persistent_service/server/src/ns_npp_notification_manager.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_notification_manager.cpp new file mode 100644 index 00000000..73ce8382 --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of singleton class CNotificationManager. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#include <native_service/ns_np_service.h> +#include <native_service/ns_message_center_if.h> +#include <native_service/ns_np_service_protocol.h> +#include <algorithm> +#include <utility> +#include <string> +#include <vector> +#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 <sstream> +#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<std::string>(); // LCOV_EXCL_BR_LINE 11: unexpected branch + + m_pvUserPersistentList = new(std::nothrow) std::vector<std::string>(); // 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<CStateNotification *>(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(); + + // <<notification type is eFrameworkunifiedUnknown + // if some service had already subscribed to the notification before registering it.>> + 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<std::string>::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<std::string> *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<std::string>::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<std::string> *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<std::string>::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<CStateNotification *>(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<CStateNotification *>(l_pNotification); + + if (NULL != l_pStateNotification) { // LCOV_EXCL_BR_LINE 5: fail safe for static_cast<CStateNotification *> + 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<CNotificationsToPersist *> + *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<std::string> *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<CStatePersistenceNotification *>(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<CStateNotification *>(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<CStatePersistenceNotification *> + (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<CNotificationsToPersist *> + *f_pvpersistnotification) { + EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + CStateNotification *l_pNotification = NULL; + CNotificationsToPersist *l_pNotificationsToPersist = NULL; + + std::vector<std::string> *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<std::string>::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<CStateNotification *>(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<CStatePersistenceNotification *> + (l_pStateNotification))->GetPersistentCategory(); + } + + if (eFrameworkunifiedImmediatePersistedStateVar == f_pnotificationstopersist->m_ePersistentType) { + CStateNorPersistenceNotification *l_pStateNorPersistenceNotification = + static_cast<CStateNorPersistenceNotification *>(l_pStateNotification); + f_pnotificationstopersist->m_uiDelay = l_pStateNorPersistenceNotification->GetPersistenceDelay(); + f_pnotificationstopersist->m_ePersistCategory = (static_cast<CStateNorPersistenceNotification *> + (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<CStatePersistenceNotification *>(l_pStateNotification))->SetPersistentCategory( + f_epersistcategory); + } else if (eFrameworkunifiedImmediatePersistedStateVar == l_eNotificationType) { + l_estatus = (static_cast<CStateNorPersistenceNotification *>(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<CStateNorPersistenceNotification *>(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/nsframework/notification_persistent_service/server/src/ns_npp_notification_receiver.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_notification_receiver.cpp new file mode 100644 index 00000000..53b9eab8 --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \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/nsframework/notification_persistent_service/server/src/ns_npp_persist_file.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_persist_file.cpp new file mode 100644 index 00000000..4b0e4522 --- /dev/null +++ b/nsframework/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 <unistd.h> +#include <string> +#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/nsframework/notification_persistent_service/server/src/ns_npp_persist_folder.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_persist_folder.cpp new file mode 100644 index 00000000..87b1ed49 --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief +/// +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +#include <unistd.h> +#include <native_service/frameworkunified_multithreading.h> +#include <string> +#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/nsframework/notification_persistent_service/server/src/ns_npp_persistence.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_persistence.cpp new file mode 100644 index 00000000..a39b8360 --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CPersistence. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#ifdef AGL_STUB +#include <other_service/strlcpy.h> +// #include "frameworkunified_stub.h" +#endif +#include <unistd.h> +#include <stdlib.h> // for getenv() +#ifdef AGL_STUB +#include <cstdio> +#endif +#include <utility> +#include <string> +#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<CRegistryEntry &>(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<CRegistryEntry &>(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<CRegistryEntry &>(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/nsframework/notification_persistent_service/server/src/ns_npp_persistence_manager.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_persistence_manager.cpp new file mode 100644 index 00000000..7f5d292f --- /dev/null +++ b/nsframework/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 <stdio.h> +#include <dirent.h> +#include <sys/types.h> +#include <native_service/ns_np_service.h> +#include <native_service/ns_np_service_if.h> +#include <native_service/ns_util_directory.h> +#include <native_service/ns_np_service_protocol.h> +#include <native_service/frameworkunified_sm_framework_dispatch.h> +#include <string> +#include <native_service/ns_np_service_nor_persistence_internal.h> +#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/nsframework/notification_persistent_service/server/src/ns_npp_persistent_data.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_persistent_data.cpp new file mode 100644 index 00000000..8a9127ef --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \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<PCHAR>(m_pMessage)); // LCOV_EXCL_BR_LINE 11: unexpected branch + m_pMessage = NULL; + } +} + + + + + + diff --git a/nsframework/notification_persistent_service/server/src/ns_npp_personalization_manager.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_personalization_manager.cpp new file mode 100644 index 00000000..43714653 --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CnotificationpersistentservicePersonalizationManager. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <utility> +#include <string> +#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/nsframework/notification_persistent_service/server/src/ns_npp_registry_entry.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_registry_entry.cpp new file mode 100644 index 00000000..dc745808 --- /dev/null +++ b/nsframework/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 <string> +#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/nsframework/notification_persistent_service/server/src/ns_npp_regular_notification.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_regular_notification.cpp new file mode 100644 index 00000000..6d75091e --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CRegularNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// + + +#include <native_service/frameworkunified_framework_if.h> +#include <native_service/ns_message_center_if.h> +#include <native_service/ns_np_service_protocol.h> +#include <mqueue.h> +#include <iostream> +#include <string> +#include <native_service/ns_mc_system_info.h> +#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/nsframework/notification_persistent_service/server/src/ns_npp_state_nor_persistence_notification.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_state_nor_persistence_notification.cpp new file mode 100644 index 00000000..7898f38e --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CStateNorPersistenceNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <errno.h> +#include <native_service/ns_message_center_if.h> +#include <string> +#include <iostream> + +#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<UI_32>(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<UI_32>(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/nsframework/notification_persistent_service/server/src/ns_npp_state_notification.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_state_notification.cpp new file mode 100644 index 00000000..ff8f054f --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CStateNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <iostream> +#include <string> +#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<PCHAR>(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/nsframework/notification_persistent_service/server/src/ns_npp_state_persistence_notification.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_state_persistence_notification.cpp new file mode 100644 index 00000000..1bb9dd11 --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CStatePersistenceNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <iostream> +#include <string> +#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/nsframework/notification_persistent_service/server/src/ns_npp_state_persistence_user_notification.cpp b/nsframework/notification_persistent_service/server/src/ns_npp_state_persistence_user_notification.cpp new file mode 100644 index 00000000..222ada31 --- /dev/null +++ b/nsframework/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 <<Group Tag>> <<Group Name>> +/// \ingroup tag_NS_NPPService +/// . +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_NS_NPPService +/// \brief This file contains implementation of class CStatePersistenceUserNotification. +/// +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Include Files +//////////////////////////////////////////////////////////////////////////////////////////////////// +#include <iostream> +#include <string> +#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__, "-"); +} |