1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "event_export_task.h"
17
18 #include "file_util.h"
19 #include "hiview_logger.h"
20 #include "setting_observer_manager.h"
21 #include "sys_event_sequence_mgr.h"
22
23 namespace OHOS {
24 namespace HiviewDFX {
25 DEFINE_LOG_TAG("HiView-EventExportTask");
26 using ExportEventListParsers = std::map<std::string, std::shared_ptr<ExportEventListParser>>;
27 namespace {
28 constexpr int64_t BYTE_TO_MB = 1024 * 1024;
29
GetParser(ExportEventListParsers & parsers,const std::string & path)30 std::shared_ptr<ExportEventListParser> GetParser(ExportEventListParsers& parsers,
31 const std::string& path)
32 {
33 auto iter = parsers.find(path);
34 if (iter == parsers.end()) {
35 parsers.emplace(path, std::make_shared<ExportEventListParser>(path));
36 return parsers[path];
37 }
38 return iter->second;
39 }
40
IsExportSwitchOff(std::shared_ptr<ExportConfig> config,std::shared_ptr<ExportDbManager> dbMgr)41 bool IsExportSwitchOff(std::shared_ptr<ExportConfig> config, std::shared_ptr<ExportDbManager> dbMgr)
42 {
43 bool isSwitchOff = (SettingObserverManager::GetInstance()->GetStringValue(config->exportSwitchParam.name) !=
44 config->exportSwitchParam.enabledVal);
45 if (isSwitchOff) {
46 HIVIEW_LOGI("export switch for module %{public}s is off", config->moduleName.c_str());
47 int64_t enabledSeq = dbMgr->GetExportEnabledSeq(config->moduleName);
48 if (enabledSeq != INVALID_SEQ_VAL && enabledSeq != 0) { // handle setting parameter listening error
49 dbMgr->HandleExportSwitchChanged(config->moduleName, INVALID_SEQ_VAL);
50 }
51 return true;
52 }
53 HIVIEW_LOGI("export switch for module %{public}s is on", config->moduleName.c_str());
54 int64_t enabledSeq = dbMgr->GetExportEnabledSeq(config->moduleName);
55 if (enabledSeq == INVALID_SEQ_VAL) { // handle setting parameter listening error
56 enabledSeq = EventStore::SysEventSequenceManager::GetInstance().GetSequence();
57 dbMgr->HandleExportSwitchChanged(config->moduleName, enabledSeq);
58 }
59 return false;
60 }
61 }
62
OnTaskRun()63 void EventExportTask::OnTaskRun()
64 {
65 if (config_ == nullptr || dbMgr_ == nullptr) {
66 HIVIEW_LOGE("config manager or db manager is invalid");
67 return;
68 }
69 if (IsExportSwitchOff(config_, dbMgr_)) {
70 return;
71 }
72 if (FileUtil::GetFolderSize(config_->exportDir) >= static_cast<uint64_t>(config_->maxCapcity * BYTE_TO_MB)) {
73 HIVIEW_LOGE("event export directory is full");
74 return;
75 }
76 // init handler request
77 auto readReq = std::make_shared<EventReadRequest>();
78 if (!InitReadRequest(readReq)) {
79 HIVIEW_LOGE("failed to init read request");
80 return;
81 }
82 // init write handler
83 auto writeHandler = std::make_shared<EventWriteHandler>();
84 // init read handler
85 auto readHandler = std::make_shared<EventReadHandler>();
86 readHandler->SetEventExportedListener([this] (int64_t beginSeq, int64_t endSeq) {
87 HIVIEW_LOGW("finished exporting events in range [%{public}" PRId64 ", %{public}" PRId64 ")",
88 beginSeq, endSeq);
89 // sync export progress to db
90 dbMgr_->HandleExportTaskFinished(config_->moduleName, endSeq);
91 });
92 // init handler chain
93 readHandler->SetNextHandler(writeHandler);
94 // start handler chain
95 if (!readHandler->HandleRequest(readReq)) {
96 HIVIEW_LOGE("failed to export all events in range [%{public}" PRId64 ",%{public}" PRId64 ")",
97 readReq->beginSeq, readReq->endSeq);
98 return;
99 }
100 // record export progress
101 HIVIEW_LOGI("succeed to export all events in range [%{public}" PRId64 ",%{public}" PRId64 ")", readReq->beginSeq,
102 readReq->endSeq);
103 }
104
ParseExportEventList(ExportEventList & list) const105 bool EventExportTask::ParseExportEventList(ExportEventList& list) const
106 {
107 ExportEventListParsers parsers;
108 auto iter = std::max_element(config_->eventsConfigFiles.begin(), config_->eventsConfigFiles.end(),
109 [&parsers] (const std::string& path1, const std::string& path2) {
110 auto parser1 = GetParser(parsers, path1);
111 auto parser2 = GetParser(parsers, path2);
112 return parser1->GetConfigurationVersion() < parser2->GetConfigurationVersion();
113 });
114 if (iter == config_->eventsConfigFiles.end()) {
115 HIVIEW_LOGE("no event list file path is configured.");
116 return false;
117 }
118 HIVIEW_LOGD("event list file path is %{public}s", (*iter).c_str());
119 auto parser = GetParser(parsers, *iter);
120 parser->GetExportEventList(list);
121 return true;
122 }
123
InitReadRequest(std::shared_ptr<EventReadRequest> readReq) const124 bool EventExportTask::InitReadRequest(std::shared_ptr<EventReadRequest> readReq) const
125 {
126 if (readReq == nullptr) {
127 return false;
128 }
129 readReq->beginSeq = dbMgr_->GetExportBeginSeq(config_->moduleName);
130 if (readReq->beginSeq == INVALID_SEQ_VAL) {
131 HIVIEW_LOGE("invalid export: begin sequence:%{public}" PRId64 "", readReq->beginSeq);
132 return false;
133 }
134 readReq->endSeq = EventStore::SysEventSequenceManager::GetInstance().GetSequence();
135 if (readReq->beginSeq >= readReq->endSeq) {
136 HIVIEW_LOGE("invalid export range: [%{public}" PRId64 ",%{public}" PRId64 ")",
137 readReq->beginSeq, readReq->endSeq);
138 return false;
139 }
140 if (!ParseExportEventList(readReq->eventList) || readReq->eventList.empty()) {
141 HIVIEW_LOGE("failed to get a valid event export list");
142 return false;
143 }
144 readReq->moduleName = config_->moduleName;
145 readReq->maxSize = config_->maxSize;
146 readReq->exportDir = config_->exportDir;
147 return true;
148 }
149 } // HiviewDFX
150 } // OHOS