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 #define MLOG_TAG "MediaLibraryRestore"
16
17 #include "acl.h"
18 #include "medialibrary_restore.h"
19 #include "dfx_utils.h"
20 #include "medialibrary_data_manager.h"
21 #include "medialibrary_tracer.h"
22 #include "media_file_utils.h"
23 #include "media_log.h"
24 #include "parameter.h"
25 #include "parameters.h"
26 #include "post_event_utils.h"
27 #ifdef CLOUD_SYNC_MANAGER
28 #include "cloud_sync_manager.h"
29 #endif
30
31 namespace OHOS {
32 namespace Media {
33 namespace {
34 const std::string SWITCH_STATUS_KEY = "persist.multimedia.medialibrary.rdb_switch_status";
35 const std::string CLOUD_STOP_FLAG_K = "persist.kernel.medialibrarydata.stopflag";
36 const std::string CLOUD_STOP_FLAG_V = "1";
37 constexpr int PARAMETER_E_OK = 0;
38 constexpr int WAIT_SECONDS = 120;
39 constexpr int SLEEP_SECONDS = 60;
40 constexpr int MAX_RETRY_TIMES = 2;
41 enum HA_SWITCH_STATUS : uint32_t {
42 HA_SWITCH_READY = 0,
43 HA_SWITCHING = 1
44 };
45 } // namespace
46
GetInstance()47 MediaLibraryRestore &MediaLibraryRestore::GetInstance()
48 {
49 static MediaLibraryRestore instance;
50 return instance;
51 }
52
SaveHAModeSwitchStatusToPara(const int64_t & status)53 void MediaLibraryRestore::SaveHAModeSwitchStatusToPara(const int64_t &status)
54 {
55 int ret = SetParameter(SWITCH_STATUS_KEY.c_str(), std::to_string(status).c_str());
56 CHECK_AND_RETURN_LOG((ret == PARAMETER_E_OK), "MediaLibraryRestore SetParameter switch error");
57 }
58
CheckRestore(const int32_t & errCode)59 void MediaLibraryRestore::CheckRestore(const int32_t &errCode)
60 {
61 if (errCode != NativeRdb::E_SQLITE_CORRUPT) {
62 return;
63 }
64 MEDIA_INFO_LOG("Restore is called");
65 CHECK_AND_RETURN_LOG((!isRestoring_), "RdbStore is restoring");
66
67 std::string date = DfxUtils::GetCurrentDateMillisecond();
68 VariantMap map = {{KEY_DB_CORRUPT, std::move(date)}};
69 PostEventUtils::GetInstance().PostErrorProcess(ErrType::DB_CORRUPT_ERR, map);
70
71 isRestoring_ = true;
72 std::thread([] {
73 MEDIA_INFO_LOG("MediaLibraryRestore::Restore [start]");
74 auto rdb = MediaLibraryDataManager::GetInstance()->rdbStore_;
75 if (rdb == nullptr) {
76 MediaLibraryRestore::GetInstance().isRestoring_ = false;
77 MEDIA_ERR_LOG("Restore rdbStore is nullptr");
78 return;
79 }
80
81 int retryTimes = MAX_RETRY_TIMES;
82 int errCode = NativeRdb::E_OK;
83 do {
84 MediaLibraryTracer tracer;
85 tracer.Start("MediaLibraryRestore::Restore");
86 errCode = rdb->Restore("");
87 MEDIA_INFO_LOG("MediaLibraryRestore::Restore errCode = %{public}d", errCode);
88 if (errCode == NativeRdb::E_SQLITE_BUSY) {
89 retryTimes--;
90 continue;
91 }
92 break;
93 } while (retryTimes > 0);
94 MEDIA_INFO_LOG("MediaLibraryRestore::Restore [end]. errCode = %{public}d", errCode);
95 MediaLibraryRestore::GetInstance().isRestoring_ = false;
96 }).detach();
97 }
98
99 #ifdef CLOUD_SYNC_MANAGER
StopCloudSync()100 void MediaLibraryRestore::StopCloudSync()
101 {
102 MediaLibraryTracer tracer;
103 tracer.Start("MediaLibraryRestore::StopCloudSync");
104 FileManagement::CloudSync::CloudSyncManager::GetInstance().StopSync(BUNDLE_NAME, true);
105 uint32_t times = 0;
106 int ret = WaitParameter(CLOUD_STOP_FLAG_K.c_str(), CLOUD_STOP_FLAG_V.c_str(), WAIT_SECONDS);
107 if (ret == PARAMETER_E_OK) {
108 MEDIA_INFO_LOG("StopCloudSync success end");
109 return;
110 }
111 isBackuping_ = false;
112 MEDIA_INFO_LOG("StopCloudSync timeout error, set backup false");
113 return;
114 }
115 #endif
116
CheckBackup()117 void MediaLibraryRestore::CheckBackup()
118 {
119 MEDIA_INFO_LOG("CheckBackup is called");
120 CHECK_AND_RETURN_LOG((!isRestoring_), "CheckBackup: is restoring, return");
121
122 auto rdb = MediaLibraryDataManager::GetInstance()->rdbStore_;
123 CHECK_AND_RETURN_LOG((rdb != nullptr), "CheckBackup: rdbStore is nullptr");
124 if (!rdb->IsSlaveDiffFromMaster()) {
125 MEDIA_INFO_LOG("CheckBackup: isSlaveDiffFromMaster [false], return");
126 return;
127 }
128 MEDIA_INFO_LOG("CheckBackup: isSlaveDiffFromMaster [true]");
129 DoRdbBackup();
130 }
131
ResetHAModeSwitchStatus()132 void MediaLibraryRestore::ResetHAModeSwitchStatus()
133 {
134 auto switchStatus = HA_SWITCH_READY;
135 SaveHAModeSwitchStatusToPara(std::move(switchStatus));
136 #ifdef CLOUD_SYNC_MANAGER
137 auto ret = FileManagement::CloudSync::CloudSyncManager::GetInstance().StartSync(BUNDLE_NAME);
138 MEDIA_INFO_LOG("ResetHAModeSwitchStatus::StartSync [%{public}d]", ret);
139 ret = FileManagement::CloudSync::CloudSyncManager::GetInstance().DownloadThumb();
140 MEDIA_INFO_LOG("ResetHAModeSwitchStatus::DownloadThumb [%{public}d]", ret);
141 #endif
142 }
143
DoRdbBackup()144 void MediaLibraryRestore::DoRdbBackup()
145 {
146 CHECK_AND_RETURN_LOG((!isBackuping_.load()), "DoRdbBackup: is backuping, return");
147 isBackuping_ = true;
148
149 std::thread([] {
150 MEDIA_INFO_LOG("DoRdbBackup: Backup [start]");
151 {
152 MEDIA_INFO_LOG("DoRdbBackup: wait_for [start]");
153 std::unique_lock<std::mutex> lock(MediaLibraryRestore::GetInstance().mutex_);
154 MediaLibraryRestore::GetInstance().cv_.wait_for(lock, std::chrono::seconds(SLEEP_SECONDS),
155 [] { return !MediaLibraryRestore::GetInstance().IsBackuping(); });
156 MEDIA_INFO_LOG("DoRdbBackup: wait_for [end]");
157 }
158 CHECK_AND_RETURN_LOG((MediaLibraryRestore::GetInstance().IsBackuping()),
159 "DoRdbBackup: after sleep isbackuping fasle, return");
160 auto currentTime = MediaFileUtils::UTCTimeSeconds();
161 MediaLibraryRestore::GetInstance().SaveHAModeSwitchStatusToPara(currentTime);
162 #ifdef CLOUD_SYNC_MANAGER
163 MediaLibraryRestore::GetInstance().StopCloudSync();
164 #endif
165 auto rdb = MediaLibraryDataManager::GetInstance()->rdbStore_;
166 if (rdb == nullptr || !MediaLibraryRestore::GetInstance().IsBackuping()) {
167 MediaLibraryRestore::GetInstance().ResetHAModeSwitchStatus();
168 MediaLibraryRestore::GetInstance().isBackuping_ = false;
169 MEDIA_ERR_LOG("DoRdbBackup: rdb is nullptr or interrupt or isbackuping false");
170 return;
171 }
172 MediaLibraryTracer tracer;
173 tracer.Start("MediaLibraryRestore::DoRdbBackup Backup");
174 MediaLibraryRestore::GetInstance().isDoingBackup_ = true;
175 int errCode = rdb->Backup("");
176 MediaLibraryRestore::GetInstance().isDoingBackup_ = false;
177 if (errCode == NativeRdb::E_OK) {
178 Acl::AclSetSlaveDatabase();
179 }
180 MEDIA_INFO_LOG("DoRdbBackup: Backup [end]. errCode = %{public}d", errCode);
181 MediaLibraryRestore::GetInstance().ResetHAModeSwitchStatus();
182 if (errCode != NativeRdb::E_CANCEL) {
183 MediaLibraryRestore::GetInstance().isBackuping_ = false;
184 }
185 }).detach();
186 }
187
InterruptBackup()188 void MediaLibraryRestore::InterruptBackup()
189 {
190 if (!isBackuping_.load()) {
191 MEDIA_INFO_LOG("rdb is not backuping, no need to interrupt");
192 return;
193 }
194 auto rdb = MediaLibraryDataManager::GetInstance()->rdbStore_;
195 CHECK_AND_RETURN_LOG((rdb != nullptr), "[InterruptBackup] rdbStore is nullptr");
196 int errCode = rdb->InterruptBackup();
197 isBackuping_ = false;
198 cv_.notify_all();
199 MEDIA_INFO_LOG("InterruptBackup [end]. errCode = %{public}d", errCode);
200 }
201
CheckResultSet(const std::shared_ptr<NativeRdb::ResultSet> & resultSet)202 void MediaLibraryRestore::CheckResultSet(const std::shared_ptr<NativeRdb::ResultSet> &resultSet)
203 {
204 MediaLibraryTracer tracer;
205 tracer.Start("CheckResultSet");
206 if (resultSet == nullptr) {
207 return;
208 }
209 int count;
210 int errCode = resultSet->GetRowCount(count);
211 CheckRestore(errCode);
212 }
213
IsRestoring() const214 bool MediaLibraryRestore::IsRestoring() const
215 {
216 return isRestoring_;
217 }
218
IsBackuping() const219 bool MediaLibraryRestore::IsBackuping() const
220 {
221 return isBackuping_.load();
222 }
223
IsRealBackuping() const224 bool MediaLibraryRestore::IsRealBackuping() const
225 {
226 return isDoingBackup_;
227 }
228 } // namespace Media
229 } // namespace OHOS
230