video_in_hal/systemservice/logger_service/server/src/ss_logger_reader_writer_control.cpp

   1 /*
   2  * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * ss_logger_reader_writer_control.cpp
  19  */
  20 #include "ss_logger_reader_writer_control.h"
  21 #include <boost/bind.hpp>
  22 #include <native_service/ns_sharedmem.h>
  23 #include <native_service/ns_transmit_log.h>
  24 #include <native_service/ns_logger_if.h>
  25 #include <string>
  26 #include "ss_logger_common.h"
  27
  28 #define LOGGERSERVICELOG_REMOTE_IP_PORT    3500
  29 #define TRANSMIT_REMOTE_IP_PORT    3500
  30
  31 CReaderWriterControl::CReaderWriterControl()
  32     : m_pLoggerCfg(NULL) {  // LCOV_EXCL_BR_LINE 11:Unexpected branch
  33 }
  34
  35 CReaderWriterControl::~CReaderWriterControl() {  // LCOV_EXCL_START 14:globle instance
  36   AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  37 }
  38 // LCOV_EXCL_STOP
  39
  40 EFrameworkunifiedStatus CReaderWriterControl::Initialize(CLoggerCfg * f_pLoggerCfg) {
  41   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  42   if (NULL != f_pLoggerCfg) {  // LCOV_EXCL_BR_LINE 200:As it is not always NULL
  43     this->m_pLoggerCfg = f_pLoggerCfg;
  44
  45     l_eStatus = m_debugReaderWriter.Initialize(  // LCOV_EXCL_BR_LINE 11:Unexpected branch
  46         f_pLoggerCfg, ReaderWriter::eReaderWriterTypeMem, std::string(FRAMEWORKUNIFIEDLOG_SHAREDMEM_NAME),
  47         FRAMEWORKUNIFIEDLOG_SHAREDMEM_SIZE, ReaderWriter::eReaderWriterTypeUdp,
  48         std::string("169.254.80.9"), LOGGERSERVICELOG_REMOTE_IP_PORT, "", 0);  // LCOV_EXCL_BR_LINE 11:except,C++ STL
  49     if (eFrameworkunifiedStatusOK == l_eStatus) {  // LCOV_EXCL_BR_LINE 200:To ensure success
  50       l_eStatus = m_debugReaderWriter.Start(std::string("pdg.LogQueR"));
  51     }
  52
  53     LOG_STATUS_IF_ERRORED(  // LCOV_EXCL_BR_LINE 15:macro
  54         l_eStatus, "m_debugReaderWriter.Start(std::string(pdg.TransQueR)");
  55
  56
  57     l_eStatus = m_transmitReaderWriter.Initialize(  // LCOV_EXCL_BR_LINE 11:Unexpected branch
  58         f_pLoggerCfg, ReaderWriter::eReaderWriterTypeMem,
  59         std::string(TRANSMIT_LOG_SHAREDMEM_NAME), TRANSMIT_LOG_SHAREDMEM_SIZE,
  60         ReaderWriter::eReaderWriterTypeUdp, std::string("169.254.80.9"),
  61         TRANSMIT_REMOTE_IP_PORT, "", 0);  // LCOV_EXCL_BR_LINE 11:except,C++ STL
  62     if (eFrameworkunifiedStatusOK == l_eStatus) {    // LCOV_EXCL_BR_LINE 6:it can not be fail
  63       l_eStatus = m_transmitReaderWriter.Start(std::string("pdg.TransQueR"));  // LCOV_EXCL_BR_LINE 11:except,C++ STL
  64     }
  65
  66     LOG_STATUS_IF_ERRORED(  // LCOV_EXCL_BR_LINE 15:macro
  67         l_eStatus, "m_transmitReaderWriter.Start(std::string(pdg.TransQueR)");
  68
  69
  70     l_eStatus = m_performanceReaderWriter.Initialize(  // LCOV_EXCL_BR_LINE 11:Unexpected branch
  71         f_pLoggerCfg, ReaderWriter::eReaderWriterTypeQueue, std::string("/NSplog"), 0,
  72         ReaderWriter::eReaderWriterTypeFile, std::string(PERFORMANCE_LOG_PATH_FN),
  73         f_pLoggerCfg->m_performanceLogMaxFileSize, std::string("169.254.80.9"),
  74         0);  // LCOV_EXCL_BR_LINE 11:except,C++ STL
  75
  76     if (eFrameworkunifiedStatusOK == l_eStatus) {    // LCOV_EXCL_BR_LINE 6:it can not be fail
  77       l_eStatus = m_performanceReaderWriter.Start(
  78           std::string("pdg.PerformQueR"));  // LCOV_EXCL_BR_LINE 11:except,C++ STL
  79     }
  80
  81     LOG_STATUS_IF_ERRORED(  // LCOV_EXCL_BR_LINE 15:macro
  82         l_eStatus,
  83         "m_performanceReaderWriter.Start(std::string(pdg.PerformQueR)");
  84
  85
  86     this->m_pLoggerCfg->AddLoggingParamCB(
  87         boost::bind(&CReaderWriterControl::UpdateLoggingParams, this, _1));
  88   }
  89   return (l_eStatus);
  90 }
  91
  92 EFrameworkunifiedStatus CReaderWriterControl::UpdateLoggingParams(void* param) {
  93   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  94   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  95   l_eStatus = this->m_debugReaderWriter.UpdateLoggingParameters();
  96   LOG_STATUS_IF_ERRORED(l_eStatus,  // LCOV_EXCL_BR_LINE 15:macro
  97                         "this->m_debugReaderWriter.UpdateLoggingParameters()");
  98
  99   l_eStatus = this->m_transmitReaderWriter.UpdateLoggingParameters();
 100   LOG_STATUS_IF_ERRORED(  // LCOV_EXCL_BR_LINE 15:macro
 101       l_eStatus, "this->m_transmitReaderWriter.UpdateLoggingParameters()");
 102
 103   l_eStatus = this->m_performanceReaderWriter.UpdateLoggingParameters();
 104   LOG_STATUS_IF_ERRORED(  // LCOV_EXCL_BR_LINE 15:macro
 105       l_eStatus,
 106       "this->m_performanceReaderWriter."
 107       "UpdateLoggingParameters()");
 108
 109   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "- : %d", l_eStatus);
 110   return (l_eStatus);
 111 }
 112
 113 EFrameworkunifiedStatus CReaderWriterControl::FlushCache(EReaderWriterType f_type) {
 114   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 115   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusInvldParam;
 116   switch (f_type) {  // LCOV_EXCL_BR_LINE 8: eReaderWriterLogDebug and eReaderWriterLogInvalid can not be called
 117     // LCOV_EXCL_START 8: dead code
 118     case eReaderWriterLogDebug:
 119     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 120       l_eStatus = this->m_debugReaderWriter.FlushCache(
 121           std::string(DEBUG_LOG_PATH_FN));
 122       LOG_STATUS_IF_ERRORED(
 123           l_eStatus, "this->m_debugReaderWriter.FlushCache(DEBUG_LOG_PATH_FN)");
 124       break;
 125     // LCOV_EXCL_STOP
 126     case eReaderWriterLogTransmit:
 127       l_eStatus = this->m_transmitReaderWriter.FlushCache(
 128           std::string(TRANSMIT_LOG_PATH_FN));
 129       LOG_STATUS_IF_ERRORED(
 130           l_eStatus,
 131           "this->m_debugReaderWriter.FlushCache(TRANSMIT_LOG_PATH_FN)");
 132       break;
 133
 134     case eReaderWriterLogPerformance:
 135       l_eStatus = this->m_performanceReaderWriter.FlushCache(
 136           std::string(PERFORMANCE_LOG_PATH_FN));
 137       LOG_STATUS_IF_ERRORED(
 138           l_eStatus,
 139           "this->m_debugReaderWriter.FlushCache(PERFORMANCE_LOG_PATH_FN)");
 140       break;
 141     // LCOV_EXCL_START 8: dead code
 142     case eReaderWriterLogInvalid:
 143     default:
 144       AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 145       break;
 146     // LCOV_EXCL_STOP
 147   }
 148   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "- : %d", l_eStatus);
 149   return (l_eStatus);
 150 }
 151