--- /dev/null
+/*
+ * @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_SS_LoggerService
+/// \brief TODO
+///
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+// INCLUDES
+///////////////////////////////////////////////////////////////////////////////
+#include "ss_logger_error_event_storage.h"
+#include <stdlib.h>
+#include <sched.h>
+#include <string.h>
+#include <errno.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <string>
+#include "ss_logger_util.h"
+#include "ss_logger_error_event_archive.h"
+#include "ss_logger_fs_directory.h"
+#include "ss_logger_common.h"
+
+CLoggerErrorEventStorage::CLoggerErrorEventStorage()
+ : m_parentMcQueue(NULL),
+ m_thread(-1),
+ m_sendQueue(-1),
+ m_receiveQueue(-1),
+ m_destination(""),
+ m_mutexInit(-1),
+ m_pLoggerCfg(NULL),
+ m_logTime(0) {
+ m_responseVec.clear();
+ m_mqattr.mq_flags = 0;
+ m_mqattr.mq_maxmsg = 1;
+ m_mqattr.mq_msgsize = 32;
+ m_mqattr.mq_curmsgs = 0;
+}
+
+CLoggerErrorEventStorage::~CLoggerErrorEventStorage() { // LCOV_EXCL_START 14:globle instance
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ this->Cleanup();
+}
+// LCOV_EXCL_STOP
+
+EFrameworkunifiedStatus CLoggerErrorEventStorage::Initialize(HANDLE f_hApp,
+ std::string f_ParentName,
+ CLoggerCfg *f_pLoggerCfg) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ pthread_attr_t l_attr;
+ struct sched_param l_params;
+
+ /* Open the queue */
+ if (NULL == (m_pLoggerCfg = f_pLoggerCfg)) { // LCOV_EXCL_BR_LINE 200:As it is not always NULL
+ // LCOV_EXCL_START 200:As it is not always NULL
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusNullPointer;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. Parameter f_pLoggerCfg is NULL.");
+ // LCOV_EXCL_STOP
+ } else if (eFrameworkunifiedStatusOK != (l_eStatus = m_pLoggerCfg->GetLoggerStorageInfo(m_loggerStorageInfo))) { // LCOV_EXCL_BR_LINE 200:To ensure success // NOLINT[whitespace/line_length]
+ // LCOV_EXCL_START 200:To ensure success
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. GetLoggerStorageInfo(m_loggerStorageInfo)");
+ // LCOV_EXCL_STOP
+ } else if (NULL == (m_parentMcQueue = McOpenSender(f_ParentName.c_str()))) { // LCOV_EXCL_BR_LINE 4:NSFW
+ // LCOV_EXCL_START 4:NSFW
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusErrOther;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. McOpenSender(f_ParentName)");
+ // LCOV_EXCL_STOP
+ } else if (-1 == (this->m_sendQueue = mq_open(m_loggerStorageInfo.Name.c_str(), O_CREAT | O_WRONLY, 0666, &m_mqattr))) { // LCOV_EXCL_BR_LINE 5:C code eror // NOLINT[whitespace/line_length]
+ // LCOV_EXCL_START 5:C code eror
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusErrOther;
+ FRAMEWORKUNIFIEDLOG(
+ ZONE_ERR,
+ __FUNCTION__,
+ " Error. mq_open(ERROR_EVENT_STORAGE_QUEUE_NAME,O_CREAT | O_WRONLY, 0666, NULL)");
+ // LCOV_EXCL_STOP
+ } else if (-1 == (this->m_receiveQueue = mq_open(m_loggerStorageInfo.Name.c_str(), O_RDONLY))) { // LCOV_EXCL_BR_LINE 5:C code eror // NOLINT[whitespace/line_length]
+ // LCOV_EXCL_START 5:C code eror
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusSessionLimitMaxedOut;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. mq_open(ERROR_EVENT_STORAGE_QUEUE_NAME,O_RDONLY)");
+ // LCOV_EXCL_STOP
+ } else if (EOK != (m_mutexInit = pthread_mutex_init(&this->m_mutex, NULL))) { // LCOV_EXCL_BR_LINE 5:C code eror
+ // LCOV_EXCL_START 5:C code eror
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusFail;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. pthread_mutex_init(&this->m_mutex, NULL)");
+ // LCOV_EXCL_STOP
+ } else if (EOK != pthread_attr_init(&l_attr)) { // LCOV_EXCL_BR_LINE 5:C code eror
+ // LCOV_EXCL_START 5:C code eror
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusSemUnlockFail;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. pthread_attr_init()");
+ // LCOV_EXCL_STOP
+ } else if (EOK != pthread_attr_getschedparam(&l_attr, &l_params)) { // LCOV_EXCL_BR_LINE 5:C code eror
+ // LCOV_EXCL_START 5:C code eror
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusSemCloseFail;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. pthread_attr_getschedparam()");
+ // LCOV_EXCL_STOP
+ } else {
+ l_params.sched_priority = m_loggerStorageInfo.Priority;
+ if (EOK != pthread_attr_setinheritsched(&l_attr, PTHREAD_EXPLICIT_SCHED)) { // LCOV_EXCL_BR_LINE 5:C code eror
+ // LCOV_EXCL_START 5:C code eror
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. pthread_attr_setinheritsched()");
+ // LCOV_EXCL_STOP
+ } else if (EOK != pthread_attr_setschedparam(&l_attr, &l_params)) { // LCOV_EXCL_BR_LINE 5:C code eror
+ l_eStatus = eFrameworkunifiedStatusDbResultError;
+ FRAMEWORKUNIFIEDLOG(
+ ZONE_ERR,
+ __FUNCTION__,
+ " Error but continue. pthread_attr_setschedparam(), priority = %d: %s",
+ m_loggerStorageInfo.Priority, strerror(errno)); // LCOV_EXCL_BR_LINE 11:Unexpected branch
+ l_eStatus = eFrameworkunifiedStatusOK;
+ }
+ if (EOK != pthread_create(&this->m_thread, &l_attr, &CLoggerErrorEventStorage::ThreadFunctionWrapper, this)) { // LCOV_EXCL_BR_LINE 5:C code eror // NOLINT[whitespace/line_length]
+ // LCOV_EXCL_START 5:C code eror
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusDbRecNotFound;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. pthread_create()");
+ // LCOV_EXCL_STOP
+ } else {
+ l_eStatus = eFrameworkunifiedStatusOK;
+ }
+ }
+ if (eFrameworkunifiedStatusOK != l_eStatus) { // LCOV_EXCL_BR_LINE 200:To ensure success
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ this->Cleanup(); // LCOV_EXCL_LINE 200:To ensure success
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-: %d", l_eStatus);
+ return (l_eStatus);
+}
+
+EFrameworkunifiedStatus CLoggerErrorEventStorage::Start(
+ std::string f_target, TArtifactResponseVec f_responseVector,
+ uint32_t f_time) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ /* Start the thread*/
+ if (EOK == pthread_mutex_lock(&this->m_mutex)) { // LCOV_EXCL_BR_LINE 200:To ensure success
+ this->m_destination = f_target;
+ this->m_responseVec = f_responseVector;
+ this->m_logTime = f_time;
+ (void) pthread_mutex_unlock(&this->m_mutex);
+ }
+ UI_8 l_cmd[MAX_QUEUE_MSG_SIZE];
+ l_cmd[0] = 1;
+ if (-1 == mq_send(this->m_sendQueue, reinterpret_cast<CHAR*>(l_cmd), m_mqattr.mq_msgsize, 0)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. mq_send(this->m_sendQueue %d) return %s", m_sendQueue,
+ strerror(errno));
+ l_eStatus = eFrameworkunifiedStatusFail;
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-: %d", l_eStatus);
+ return (l_eStatus);
+}
+
+void CLoggerErrorEventStorage::ThreadFunction(void) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ char l_data[MAX_QUEUE_MSG_SIZE] = { };
+ SI_32 l_bytesRead = -1;
+ SI_32 l_oldState;
+ ELoggerStorageThreadCommands l_cmdId = eLoggerStorageThreadCmdWriteFailed;
+ EFrameworkunifiedStatus l_eStatus;
+
+ (void) pthread_setname_np(pthread_self(), ERROR_EVENT_STORAGE_QUEUE_NAME);
+
+ pthread_cleanup_push(&CLoggerErrorEventStorage::CleanupWrapper, this);
+ while (-1 // LCOV_EXCL_BR_LINE 200: mq_send can not send size of -1
+ != (l_bytesRead =
+ static_cast<SI_32>(mq_receive(this->m_receiveQueue, reinterpret_cast<char *>(l_data),
+ (size_t) m_mqattr.mq_msgsize, NULL)))) {
+ std::string l_target;
+ TArtifactResponseVec l_responseVec;
+ uint32_t l_logTime;
+ uint8_t status;
+ Clock_getSystemTimeY2K38(&l_logTime, &status);
+ (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &l_oldState);
+ if (EOK == pthread_mutex_lock(&this->m_mutex)) { // LCOV_EXCL_BR_LINE 5: pthread_mutex_lock's error case.
+ l_target = this->m_destination;
+ l_responseVec = this->m_responseVec;
+ l_logTime = this->m_logTime;
+ this->m_responseVec.clear();
+ this->m_destination = "";
+
+ (void) pthread_mutex_unlock(&this->m_mutex);
+ }
+ (void) pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &l_oldState);
+ if (access(l_target.c_str(), F_OK) == 0) {
+ if (CFSDirectory::IsDirectory(l_target)) { // LCOV_EXCL_BR_LINE 6: can not be a dir
+ // LCOV_EXCL_START 6: new file create, it can not be find
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ BOOL isDeleteFiles = FALSE;
+ SI_32 l_filesCopied = this->CopyFiles(l_target, l_responseVec,
+ isDeleteFiles);
+
+ switch (l_filesCopied) {
+ case -1:
+ /*Error while moving files*/
+ l_cmdId = eLoggerStorageThreadCmdWriteFailed;
+ break;
+ case 0:
+ /*No files where moved*/
+ l_cmdId = eLoggerStorageThreadCmdNoWritten;
+ break;
+ default:
+ if (l_filesCopied > 0) {
+ l_cmdId = eLoggerStorageThreadCmdOK;
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " Info. %d files successfully copied.", l_filesCopied);
+ }
+ break;
+ }
+ // LCOV_EXCL_STOP
+ }
+ } else {
+ if (eFrameworkunifiedStatusOK
+ != (l_eStatus = this->PackageAndPlaceArtifacts(l_target,
+ l_responseVec,
+ l_logTime))) {
+ /*Write Error.*/
+ l_cmdId = eLoggerStorageThreadCmdWriteFailed;
+ } else {
+ l_cmdId = eLoggerStorageThreadCmdOK;
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " Info. Archive successfully written.");
+ }
+ if (eFrameworkunifiedStatusOK != RemoveDeprecatedArtifacts(l_responseVec)) {
+ FRAMEWORKUNIFIEDLOG(
+ ZONE_WARN, __FUNCTION__,
+ " Warning. Wasn't able to delete all deprecated log artifacts.");
+ }
+ }
+
+ std::string l_usb_path;
+ size_t l_usb_path_length = 0;
+ if (m_pLoggerCfg != NULL) { // LCOV_EXCL_BR_LINE 6: m_pLoggerCfg can not be null
+ l_usb_path = m_pLoggerCfg->getUsb0MountPath();
+ l_usb_path_length = l_usb_path.length();
+ if ((l_usb_path_length > 1)
+ && (l_usb_path[l_usb_path.length() - 1] == '/')) {
+ l_usb_path_length--;
+ }
+ }
+ if ((l_usb_path_length > 0)
+ && (l_target.compare(0, l_usb_path_length, l_usb_path, 0,
+ l_usb_path_length) != 0)) {
+ l_usb_path_length = 0;
+ }
+ if ((l_usb_path_length == 0)
+ && (l_target.compare(0, sizeof(DEBUG_USB_PATH) - 1, DEBUG_USB_PATH, 0,
+ sizeof(DEBUG_USB_PATH) - 1) == 0)) {
+ l_usb_path = DEBUG_USB_PATH;
+ l_usb_path_length = sizeof(DEBUG_USB_PATH) - 1;
+ }
+ if (l_usb_path_length > 1) { // if USB path is '/' only, length is 1.
+ // So conditions to be syncfs is greater than 1
+ // sync usb device
+ DIR* l_dirp = opendir(l_usb_path.c_str());
+ if (l_dirp != NULL) { // LCOV_EXCL_BR_LINE 5: c code error case
+ int fd = dirfd(l_dirp);
+ if (fd != -1) { // LCOV_EXCL_BR_LINE 5: c code error case
+ if (syncfs(fd) == -1) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. syncfs failed path=%s [%s]", l_usb_path.c_str(),
+ strerror(errno));
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. syncfs get fd failed path=%s, [%s]",
+ l_usb_path.c_str(), strerror(errno));
+ }
+ closedir(l_dirp);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. syncfs opendir failed path=%s, [%s]",
+ l_usb_path.c_str(), strerror(errno));
+ }
+ {
+#define USB_MEMORY_SYNC_WAITTIME 8 // 8 sec
+ const struct timespec intval = { USB_MEMORY_SYNC_WAITTIME, 0 };
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ "%d sec:Waiting for USB Memory Synchronization.(%s)",
+ USB_MEMORY_SYNC_WAITTIME, l_usb_path.c_str());
+ nanosleep(&intval, NULL);
+ }
+ }
+ if (eFrameworkunifiedStatusOK
+ != McSend(this->m_parentMcQueue, m_loggerStorageInfo.Name.c_str(),
+ l_cmdId, 0, NULL)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. McSend(this->m_parentMcQueue)");
+ }
+ }
+ pthread_cleanup_pop(1);
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+}
+
+void CLoggerErrorEventStorage::Cleanup(void) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ if (-1 != this->m_receiveQueue) { // LCOV_EXCL_BR_LINE 200: m_receiveQueue cam not be -1
+ if (-1 == mq_close(this->m_receiveQueue)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. mq_close()");
+ }
+ this->m_receiveQueue = -1;
+ }
+ if (-1 != this->m_sendQueue) { // LCOV_EXCL_BR_LINE 200: m_sendQueue cam not be -1
+ if (-1 == mq_close(this->m_sendQueue)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. mq_close()");
+ }
+ this->m_sendQueue = -1;
+ if (-1 == mq_unlink(m_loggerStorageInfo.Name.c_str())) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. mq_unlink()");
+ }
+ }
+
+ if (-1 != m_mutexInit) { // LCOV_EXCL_BR_LINE 200: m_mutexInit cam not be -1
+ if (EOK != pthread_mutex_destroy(&this->m_mutex)) { // LCOV_EXCL_BR_LINE 5: c code error case
+ // LCOV_EXCL_START 5: c code error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. mq_unlink()");
+ // LCOV_EXCL_STOP
+ }
+ m_mutexInit = -1;
+ }
+
+ if (NULL != m_parentMcQueue) { // LCOV_EXCL_BR_LINE 200: m_parentMcQueue cam not be null
+ if (eFrameworkunifiedStatusOK != McClose(m_parentMcQueue)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. McClose()");
+ }
+ this->m_parentMcQueue = NULL;
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+}
+
+void* CLoggerErrorEventStorage::ThreadFunctionWrapper(void* param) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ CLoggerErrorEventStorage* l_pObj =
+ reinterpret_cast<CLoggerErrorEventStorage *>(param);
+
+ l_pObj->ThreadFunction();
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return NULL;
+}
+
+void CLoggerErrorEventStorage::CleanupWrapper(void* param) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ CLoggerErrorEventStorage* l_pObj =
+ reinterpret_cast<CLoggerErrorEventStorage *>(param);
+
+ l_pObj->Cleanup();
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+}
+
+///////////////////////////////////////////////////////////////////////////
+// Function : PackageAndPlaceArtifacts
+// brief : This function creates an archive for all collected artifacts
+// and places the archive in the required location depending
+// on the event type and required naming criteria.
+///////////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus CLoggerErrorEventStorage::PackageAndPlaceArtifacts(
+ std::string f_archiveDestination, TArtifactResponseVec &f_responseVector,
+ uint32_t f_logTime) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ std::string l_coreFileName = "";
+ SI_32 l_ret = 0;
+
+ if (f_archiveDestination.size() == 0) {
+ FRAMEWORKUNIFIEDLOG(
+ ZONE_ERR,
+ __FUNCTION__,
+ " Error. Unknown package file path and name. Logging artifacts not stored!");
+ l_eStatus = eFrameworkunifiedStatusFail;
+ } else {
+ CErrorEventArchive l_archiver;
+ l_eStatus = l_archiver.openArchive(f_archiveDestination);
+ if (eFrameworkunifiedStatusOK != l_eStatus) { // LCOV_EXCL_BR_LINE 6: it can not be fail
+ // LCOV_EXCL_START 6: it can not be fail
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(
+ ZONE_ERR,
+ __FUNCTION__,
+ " Error. Failed to create logging archive: %s. Log archive will not be stored!",
+ f_archiveDestination.c_str());
+ // LCOV_EXCL_STOP
+ } else {
+ for (UI_32 i = 0; (i < f_responseVector.size()); i++) {
+ if (f_responseVector[i].Filepath != std::string("")) {
+ std::string l_destName = f_responseVector[i].Filepath;
+
+ if ((f_responseVector[i].Filepath.find(".bmp") // LCOV_EXCL_BR_LINE 200: no bmp file be set
+ == f_responseVector[i].Filepath.find_last_of('.'))
+ && (f_responseVector[i].Filepath.find(".bmp")
+ != std::string::npos)) {
+ // LCOV_EXCL_START 200: no bmp file be set
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ char buffer[20];
+ struct tm local_time;
+ Clock_getLocalTimeY2K38(&f_logTime, &local_time);
+ if (0
+ != strftime(buffer, sizeof(buffer), "%Y%m%d%H%M%S.bmp",
+ &local_time)) {
+ l_destName = buffer;
+ }
+ // LCOV_EXCL_STOP
+ } else {
+ l_destName = f_responseVector[i].Filepath.substr(
+ f_responseVector[i].Filepath.find_last_of('/') + 1);
+ }
+ if (f_responseVector[i].ArtifactId == eArtifactIdPstoreLog) { // LCOV_EXCL_BR_LINE 200: can not be eArtifactIdPstoreLog // NOLINT[whitespace/line_length]
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_destName = KERNEL_LOG_PATH_DIR; // LCOV_EXCL_LINE 200: can not be eArtifactIdPstoreLog
+ }
+ l_eStatus = l_archiver.addToArchive(f_responseVector[i].Filepath,
+ l_destName);
+ if (eFrameworkunifiedStatusOK != l_eStatus) { // LCOV_EXCL_BR_LINE 200: can not be fail
+ // LCOV_EXCL_START 200: can not be fail
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(
+ ZONE_ERR,
+ __FUNCTION__,
+ " Error. Failed to add artifact: %s to archive %s. Continuing with next artifact.",
+ f_responseVector[i].Filepath.c_str(),
+ f_archiveDestination.c_str());
+ // LCOV_EXCL_STOP
+ }
+ l_ret++;
+ if ((l_ret % m_loggerStorageInfo.TimeoutAfter) == 0) {
+ usleep(m_loggerStorageInfo.Timeout);
+ }
+ }
+ }
+
+ if (eFrameworkunifiedStatusOK != l_archiver.closeArchive()) { // LCOV_EXCL_BR_LINE 200: closeArchive can not be fail
+ // LCOV_EXCL_START 200: closeArchive can not be fail
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusFail;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. l_archiver.closeArchive()");
+ // LCOV_EXCL_STOP
+ } else {
+ // Cleanup artifacts that are no longer required.
+ int rc = access(f_archiveDestination.c_str(), F_OK);
+ if (0 != rc) { // LCOV_EXCL_BR_LINE 5: f_archiveDestination is aways exist
+ // LCOV_EXCL_START 5: f_archiveDestination is aways exist
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. Archive verification failed. Errno: %d, %s.", errno,
+ strerror(errno));
+ l_eStatus = eFrameworkunifiedStatusFail;
+ // LCOV_EXCL_STOP
+ } else {
+ TEXT(__FUNCTION__,
+ " Error Event: A archive successfully written to: %s.",
+ f_archiveDestination.c_str());
+ l_eStatus = eFrameworkunifiedStatusOK;
+ }
+ }
+ }
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eStatus);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////
+/// File Copy
+/// arg:
+/// isDeleteFiles : TRUE - delete original files after copy.
+/// FALSE - not delete after copy.
+/// returns:
+/// -1: error while writing
+/// else, number of files written
+///////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////
+// LCOV_EXCL_START 8: can not be called
+SI_32 CLoggerErrorEventStorage::CopyFiles(
+ std::string f_destination, TArtifactResponseVec &f_responseVector,
+ BOOL isDeleteFiles) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ SI_32 l_ret = 0;
+ BOOL l_isFaile = FALSE;
+ for (UI_32 i = 0; i < f_responseVector.size(); i++) {
+ if (f_responseVector[i].Filepath != "") {
+ if (CFSDirectory::IsDirectory(f_responseVector[i].Filepath)) {
+ DIR * l_pDir = opendir(f_responseVector[i].Filepath.c_str());
+ if (l_pDir == NULL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Could not open directory: %s",
+ f_responseVector[i].Filepath.c_str());
+ } else {
+ struct dirent l_pDirent;
+ struct dirent* next;
+ while (0 == readdir_r(l_pDir, &l_pDirent, &next) && next != NULL) {
+ if ((0 != strcmp(l_pDirent.d_name, ".")) && /* Ignore special . directory. */
+ (0 != strcmp(l_pDirent.d_name, "..")) && /* Ignore special .. directory. */
+ (0 != strcmp(l_pDirent.d_name, "lost+found")) && /* Ignore lost+found. */
+ ('.' != l_pDirent.d_name[0])) { /* Ignore hidden files */
+ std::string l_fileSource = f_responseVector[i].Filepath;
+ std::string l_fileDestination = f_destination;
+ l_fileSource.append("/");
+ l_fileSource.append(l_pDirent.d_name);
+ l_fileDestination.append("/");
+ l_fileDestination.append(l_pDirent.d_name);
+ EFrameworkunifiedStatus loggerserviceRet = eFrameworkunifiedStatusOK;
+ if (isDeleteFiles == TRUE) {
+ loggerserviceRet = CLoggerUtil::MoveUntyped(l_fileSource,
+ l_fileDestination);
+ } else {
+ loggerserviceRet = CLoggerUtil::CopyUntyped(l_fileSource,
+ l_fileDestination);
+ }
+
+ if (eFrameworkunifiedStatusOK == loggerserviceRet) {
+ l_ret++;
+ if ((l_ret % m_loggerStorageInfo.TimeoutAfter) == 0) {
+ usleep(m_loggerStorageInfo.Timeout);
+ }
+ } else {
+ l_isFaile = TRUE;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Could not move: %s",
+ l_fileSource.c_str());
+ }
+ }
+ }
+ (void) closedir(l_pDir);
+ }
+ } else {
+ std::string l_filename = f_responseVector[i].Filepath.substr(
+ f_responseVector[i].Filepath.find_last_of('/'));
+ std::string l_destination = std::string(f_destination).append(
+ l_filename);
+ if (eFrameworkunifiedStatusOK
+ == CLoggerUtil::MoveUntyped(f_responseVector[i].Filepath,
+ l_destination)) {
+ l_ret++;
+ if ((l_ret % m_loggerStorageInfo.TimeoutAfter) == 0) {
+ usleep(m_loggerStorageInfo.Timeout);
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Could not move: %s",
+ f_responseVector[i].Filepath.c_str());
+ l_isFaile = TRUE;
+ }
+ }
+ }
+ }
+ if (l_isFaile)
+ l_ret = -1;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_ret);
+}
+// LCOV_EXCL_STOP
+
+EFrameworkunifiedStatus CLoggerErrorEventStorage::RemoveDeprecatedArtifacts(
+ TArtifactResponseVec &f_responseVector) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ BOOL l_success = TRUE;
+ for (UI_32 i = 0; i < f_responseVector.size(); i++) {
+ if ((f_responseVector[i].Filepath != "")
+ && (TRUE == f_responseVector[i].Remove)) {
+ if (CFSDirectory::IsDirectory(f_responseVector[i].Filepath)) {
+ if (TRUE
+ != CFSDirectory::RemoveDirectory(f_responseVector[i].Filepath)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
+ " Warning. Directory %s failed to be deleted.",
+ f_responseVector[i].Filepath.c_str());
+ l_success &= FALSE;
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " Info. Directory %s has been successfully deleted.",
+ f_responseVector[i].Filepath.c_str());
+ }
+
+ } else {
+ errno = 0;
+ if (0 != remove(f_responseVector[i].Filepath.c_str())) { // LCOV_EXCL_BR_LINE 5: c code error case
+ // LCOV_EXCL_START 5: c code error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ if (errno == ENOENT) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " Info. %s not available. Skipping file deletion.",
+ f_responseVector[i].Filepath.c_str());
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
+ " Warning. File %s failed to be deleted.",
+ f_responseVector[i].Filepath.c_str());
+ l_success &= FALSE;
+ }
+ errno = 0;
+ // LCOV_EXCL_STOP
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " Info. File %s has been successfully deleted.",
+ f_responseVector[i].Filepath.c_str());
+ }
+ }
+ }
+ }
+ l_eStatus = (l_success == TRUE) ? eFrameworkunifiedStatusOK : eFrameworkunifiedStatusFail;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
Code Review / staging / basesystem.git / blobdiff