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 "sqlite_single_ver_natural_store.h"
17 
18 #include <algorithm>
19 #include <thread>
20 #include <chrono>
21 
22 #include "data_compression.h"
23 #include "db_common.h"
24 #include "db_constant.h"
25 #include "db_dump_helper.h"
26 #include "db_dfx_adapter.h"
27 #include "db_errno.h"
28 #include "generic_single_ver_kv_entry.h"
29 #include "intercepted_data_impl.h"
30 #include "kvdb_utils.h"
31 #include "log_print.h"
32 #include "platform_specific.h"
33 #include "schema_object.h"
34 #include "single_ver_database_oper.h"
35 #include "single_ver_utils.h"
36 #include "storage_engine_manager.h"
37 #include "sqlite_single_ver_natural_store_connection.h"
38 #include "value_hash_calc.h"
39 
40 namespace DistributedDB {
GetDbPropertyForUpdate()41 KvDBProperties &SQLiteSingleVerNaturalStore::GetDbPropertyForUpdate()
42 {
43     return MyProp();
44 }
45 
HeartBeatForLifeCycle() const46 void SQLiteSingleVerNaturalStore::HeartBeatForLifeCycle() const
47 {
48     std::lock_guard<std::mutex> lock(lifeCycleMutex_);
49     int errCode = ResetLifeCycleTimer();
50     if (errCode != E_OK) {
51         LOGE("Heart beat for life cycle failed:%d", errCode);
52     }
53 }
54 
StartLifeCycleTimer(const DatabaseLifeCycleNotifier & notifier) const55 int SQLiteSingleVerNaturalStore::StartLifeCycleTimer(const DatabaseLifeCycleNotifier &notifier) const
56 {
57     auto runtimeCxt = RuntimeContext::GetInstance();
58     if (runtimeCxt == nullptr) {
59         return -E_INVALID_ARGS;
60     }
61     RefObject::IncObjRef(this);
62     TimerId timerId = 0;
63     int errCode = runtimeCxt->SetTimer(autoLifeTime_,
64         [this](TimerId id) -> int {
65             std::lock_guard<std::mutex> lock(lifeCycleMutex_);
66             if (lifeCycleNotifier_) {
67                 std::string identifier;
68                 if (GetMyProperties().GetBoolProp(KvDBProperties::SYNC_DUAL_TUPLE_MODE, false)) {
69                     identifier = GetMyProperties().GetStringProp(KvDBProperties::DUAL_TUPLE_IDENTIFIER_DATA, "");
70                 } else {
71                     identifier = GetMyProperties().GetStringProp(KvDBProperties::IDENTIFIER_DATA, "");
72                 }
73                 auto userId = GetMyProperties().GetStringProp(DBProperties::USER_ID, "");
74                 lifeCycleNotifier_(identifier, userId);
75             }
76             return 0;
77         },
78         [this]() {
79             int ret = RuntimeContext::GetInstance()->ScheduleTask([this]() {
80                 RefObject::DecObjRef(this);
81             });
82             if (ret != E_OK) {
83                 LOGE("SQLiteSingleVerNaturalStore timer finalizer ScheduleTask, errCode %d", ret);
84             }
85         },
86         timerId);
87     if (errCode != E_OK) {
88         lifeTimerId_ = 0;
89         LOGE("SetTimer failed:%d", errCode);
90         RefObject::DecObjRef(this);
91         return errCode;
92     }
93 
94     lifeCycleNotifier_ = notifier;
95     lifeTimerId_ = timerId;
96     return E_OK;
97 }
98 
ResetLifeCycleTimer() const99 int SQLiteSingleVerNaturalStore::ResetLifeCycleTimer() const
100 {
101     if (lifeTimerId_ == 0) {
102         return E_OK;
103     }
104     auto lifeNotifier = lifeCycleNotifier_;
105     lifeCycleNotifier_ = nullptr;
106     int errCode = StopLifeCycleTimer();
107     if (errCode != E_OK) {
108         LOGE("[Reset timer]Stop the life cycle timer failed:%d", errCode);
109     }
110     return StartLifeCycleTimer(lifeNotifier);
111 }
112 
StopLifeCycleTimer() const113 int SQLiteSingleVerNaturalStore::StopLifeCycleTimer() const
114 {
115     auto runtimeCxt = RuntimeContext::GetInstance();
116     if (runtimeCxt == nullptr) {
117         return -E_INVALID_ARGS;
118     }
119     if (lifeTimerId_ != 0) {
120         TimerId timerId = lifeTimerId_;
121         lifeTimerId_ = 0;
122         runtimeCxt->RemoveTimer(timerId, false);
123     }
124     return E_OK;
125 }
126 
IsDataMigrating() const127 bool SQLiteSingleVerNaturalStore::IsDataMigrating() const
128 {
129     if (storageEngine_ == nullptr) {
130         return false;
131     }
132 
133     if (storageEngine_->IsMigrating()) {
134         LOGD("Migrating now.");
135         return true;
136     }
137     return false;
138 }
139 
SetConnectionFlag(bool isExisted) const140 void SQLiteSingleVerNaturalStore::SetConnectionFlag(bool isExisted) const
141 {
142     if (storageEngine_ != nullptr) {
143         storageEngine_->SetConnectionFlag(isExisted);
144     }
145 }
146 
TriggerToMigrateData() const147 int SQLiteSingleVerNaturalStore::TriggerToMigrateData() const
148 {
149     SQLiteSingleVerStorageEngine *storageEngine = nullptr;
150     {
151         std::lock_guard<std::shared_mutex> autoLock(engineMutex_);
152         if (storageEngine_ == nullptr) {
153             return E_OK;
154         }
155         storageEngine = storageEngine_;
156         RefObject::IncObjRef(storageEngine);
157     }
158     RefObject::IncObjRef(this);
159     int errCode = RuntimeContext::GetInstance()->ScheduleTask([this, storageEngine]() {
160         AsyncDataMigration(storageEngine);
161     });
162     if (errCode != E_OK) {
163         RefObject::DecObjRef(this);
164         RefObject::DecObjRef(storageEngine);
165         LOGE("[SingleVerNStore] Trigger to migrate data failed : %d.", errCode);
166     }
167     return errCode;
168 }
169 
IsCacheDBMode() const170 bool SQLiteSingleVerNaturalStore::IsCacheDBMode() const
171 {
172     if (storageEngine_ == nullptr) {
173         LOGE("[SingleVerNStore] IsCacheDBMode storage engine is invalid.");
174         return false;
175     }
176     EngineState engineState = storageEngine_->GetEngineState();
177     return (engineState == EngineState::CACHEDB);
178 }
179 
IsExtendedCacheDBMode() const180 bool SQLiteSingleVerNaturalStore::IsExtendedCacheDBMode() const
181 {
182     if (storageEngine_ == nullptr) {
183         LOGE("[SingleVerNStore] storage engine is invalid.");
184         return false;
185     }
186     EngineState engineState = storageEngine_->GetEngineState();
187     return (engineState == EngineState::CACHEDB || engineState == EngineState::MIGRATING ||
188         engineState == EngineState::ATTACHING);
189 }
190 
CheckReadDataControlled() const191 int SQLiteSingleVerNaturalStore::CheckReadDataControlled() const
192 {
193     if (IsExtendedCacheDBMode()) {
194         int err = IsCacheDBMode() ? -E_EKEYREVOKED : -E_BUSY;
195         LOGE("Existed cache database can not read data, errCode = [%d]!", err);
196         return err;
197     }
198     return E_OK;
199 }
200 
IncreaseCacheRecordVersion() const201 void SQLiteSingleVerNaturalStore::IncreaseCacheRecordVersion() const
202 {
203     if (storageEngine_ == nullptr) {
204         LOGE("[SingleVerNStore] Increase cache version storage engine is invalid.");
205         return;
206     }
207     storageEngine_->IncreaseCacheRecordVersion();
208 }
209 
GetCacheRecordVersion() const210 uint64_t SQLiteSingleVerNaturalStore::GetCacheRecordVersion() const
211 {
212     if (storageEngine_ == nullptr) {
213         LOGE("[SingleVerNStore] Get cache version storage engine is invalid.");
214         return 0;
215     }
216     return storageEngine_->GetCacheRecordVersion();
217 }
218 
GetAndIncreaseCacheRecordVersion() const219 uint64_t SQLiteSingleVerNaturalStore::GetAndIncreaseCacheRecordVersion() const
220 {
221     if (storageEngine_ == nullptr) {
222         LOGE("[SingleVerNStore] Get and increase cache version storage engine is invalid.");
223         return 0;
224     }
225     return storageEngine_->GetAndIncreaseCacheRecordVersion();
226 }
227 
CheckAmendValueContentForSyncProcedure(std::vector<DataItem> & dataItems) const228 void SQLiteSingleVerNaturalStore::CheckAmendValueContentForSyncProcedure(std::vector<DataItem> &dataItems) const
229 {
230     const SchemaObject &schemaObjRef = MyProp().GetSchemaConstRef();
231     if (!schemaObjRef.IsSchemaValid()) {
232         // Not a schema database, do not need to check more
233         return;
234     }
235     uint32_t deleteCount = 0;
236     uint32_t amendCount = 0;
237     uint32_t neglectCount = 0;
238     for (auto &eachItem : dataItems) {
239         if ((eachItem.flag & DataItem::DELETE_FLAG) == DataItem::DELETE_FLAG ||
240             (eachItem.flag & DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) == DataItem::REMOTE_DEVICE_DATA_MISS_QUERY) {
241             // Delete record not concerned
242             deleteCount++;
243             continue;
244         }
245         bool useAmendValue = false;
246         int errCode = CheckValueAndAmendIfNeed(ValueSource::FROM_SYNC, eachItem.value, eachItem.value, useAmendValue);
247         if (errCode != E_OK) {
248             eachItem.neglect = true;
249             neglectCount++;
250             continue;
251         }
252         if (useAmendValue) {
253             amendCount++;
254         }
255     }
256     LOGI("[SqlSinStore][CheckAmendForSync] OriCount=%zu, DeleteCount=%u, AmendCount=%u, NeglectCount=%u",
257         dataItems.size(), deleteCount, amendCount, neglectCount);
258 }
259 
NotifyRemotePushFinished(const std::string & targetId) const260 void SQLiteSingleVerNaturalStore::NotifyRemotePushFinished(const std::string &targetId) const
261 {
262     std::string identifier = DBCommon::VectorToHexString(GetIdentifier());
263     LOGI("label:%.6s sourceTarget: %s{private} push finished", identifier.c_str(), targetId.c_str());
264     NotifyRemotePushFinishedInner(targetId);
265 }
266 
CheckIntegrity() const267 int SQLiteSingleVerNaturalStore::CheckIntegrity() const
268 {
269     int errCode = E_OK;
270     auto handle = GetHandle(true, errCode);
271     if (handle == nullptr) {
272         return errCode;
273     }
274 
275     errCode = handle->CheckIntegrity();
276     ReleaseHandle(handle);
277     return errCode;
278 }
279 
SaveCreateDBTimeIfNotExisted()280 int SQLiteSingleVerNaturalStore::SaveCreateDBTimeIfNotExisted()
281 {
282     Timestamp createDBTime = 0;
283     int errCode = GetDatabaseCreateTimestamp(createDBTime);
284     if (errCode == -E_NOT_FOUND) {
285         errCode = SaveCreateDBTime();
286     }
287     if (errCode != E_OK) {
288         LOGE("SaveCreateDBTimeIfNotExisted failed, errCode=%d.", errCode);
289     }
290     return errCode;
291 }
292 
DeleteMetaDataByPrefixKey(const Key & keyPrefix) const293 int SQLiteSingleVerNaturalStore::DeleteMetaDataByPrefixKey(const Key &keyPrefix) const
294 {
295     if (keyPrefix.empty() || keyPrefix.size() > DBConstant::MAX_KEY_SIZE) {
296         return -E_INVALID_ARGS;
297     }
298 
299     int errCode = E_OK;
300     auto handle = GetHandle(true, errCode);
301     if (handle == nullptr) {
302         return errCode;
303     }
304 
305     errCode = handle->DeleteMetaDataByPrefixKey(keyPrefix);
306     if (errCode != E_OK) {
307         LOGE("[SinStore] DeleteMetaData by prefix key failed, errCode = %d", errCode);
308     }
309 
310     ReleaseHandle(handle);
311     HeartBeatForLifeCycle();
312     return errCode;
313 }
314 
GetCompressionOption(bool & needCompressOnSync,uint8_t & compressionRate) const315 int SQLiteSingleVerNaturalStore::GetCompressionOption(bool &needCompressOnSync, uint8_t &compressionRate) const
316 {
317     needCompressOnSync = GetDbProperties().GetBoolProp(KvDBProperties::COMPRESS_ON_SYNC, false);
318     compressionRate = GetDbProperties().GetIntProp(KvDBProperties::COMPRESSION_RATE,
319         DBConstant::DEFAULT_COMPTRESS_RATE);
320     return E_OK;
321 }
322 
GetCompressionAlgo(std::set<CompressAlgorithm> & algorithmSet) const323 int SQLiteSingleVerNaturalStore::GetCompressionAlgo(std::set<CompressAlgorithm> &algorithmSet) const
324 {
325     algorithmSet.clear();
326     DataCompression::GetCompressionAlgo(algorithmSet);
327     return E_OK;
328 }
329 
CheckAndInitQueryCondition(QueryObject & query) const330 int SQLiteSingleVerNaturalStore::CheckAndInitQueryCondition(QueryObject &query) const
331 {
332     const SchemaObject &localSchema = MyProp().GetSchemaConstRef();
333     if (localSchema.GetSchemaType() != SchemaType::NONE && localSchema.GetSchemaType() != SchemaType::JSON) {
334         // Flatbuffer schema is not support subscribe
335         return -E_NOT_SUPPORT;
336     }
337     query.SetSchema(localSchema);
338 
339     int errCode = E_OK;
340     SQLiteSingleVerStorageExecutor *handle = GetHandle(true, errCode);
341     if (handle == nullptr) {
342         return errCode;
343     }
344 
345     errCode = handle->CheckQueryObjectLegal(query);
346     if (errCode != E_OK) {
347         LOGE("Check query condition failed [%d]!", errCode);
348     }
349     ReleaseHandle(handle);
350     return errCode;
351 }
352 
SetSendDataInterceptor(const PushDataInterceptor & interceptor)353 void SQLiteSingleVerNaturalStore::SetSendDataInterceptor(const PushDataInterceptor &interceptor)
354 {
355     std::unique_lock<std::shared_mutex> lock(dataInterceptorMutex_);
356     pushDataInterceptor_ = interceptor;
357 }
358 
InterceptData(std::vector<SingleVerKvEntry * > & entries,const std::string & sourceID,const std::string & targetID,bool isPush) const359 int SQLiteSingleVerNaturalStore::InterceptData(std::vector<SingleVerKvEntry *> &entries, const std::string &sourceID,
360     const std::string &targetID, bool isPush) const
361 {
362     PushDataInterceptor interceptor = nullptr;
363     {
364         std::shared_lock<std::shared_mutex> lock(dataInterceptorMutex_);
365         interceptor = isPush ? pushDataInterceptor_ : receiveDataInterceptor_;
366         if (interceptor == nullptr) {
367             return E_OK;
368         }
369     }
370 
371     InterceptedDataImpl data(entries, [this](const Value &newValue) -> int {
372             bool useAmendValue = false;
373             Value amendValue = newValue;
374             return this->CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, newValue, amendValue, useAmendValue);
375         }
376     );
377 
378     int errCode = interceptor(data, sourceID, targetID);
379     if (data.IsError()) {
380         if (isPush) {
381             // receive data release by syncer
382             SingleVerKvEntry::Release(entries);
383         }
384         LOGE("Intercept data failed:%d.", errCode);
385         return -E_INTERCEPT_DATA_FAIL;
386     }
387     return E_OK;
388 }
389 
AddSubscribe(const std::string & subscribeId,const QueryObject & query,bool needCacheSubscribe)390 int SQLiteSingleVerNaturalStore::AddSubscribe(const std::string &subscribeId, const QueryObject &query,
391     bool needCacheSubscribe)
392 {
393     if (IsSupportSubscribe() != E_OK) {
394         return -E_NOT_SUPPORT;
395     }
396     const SchemaObject &localSchema = MyProp().GetSchemaConstRef();
397     QueryObject queryInner = query;
398     queryInner.SetSchema(localSchema);
399     if (IsExtendedCacheDBMode() && needCacheSubscribe) { // cache auto subscribe when engine state is in CACHEDB mode
400         LOGI("Cache subscribe query and return ok when in cacheDB.");
401         storageEngine_->CacheSubscribe(subscribeId, queryInner);
402         return E_OK;
403     }
404 
405     int errCode = E_OK;
406     SQLiteSingleVerStorageExecutor *handle = GetHandle(true, errCode);
407     if (handle == nullptr) {
408         return errCode;
409     }
410 
411     errCode = handle->StartTransaction(TransactType::IMMEDIATE);
412     if (errCode != E_OK) {
413         ReleaseHandle(handle);
414         return errCode;
415     }
416 
417     errCode = handle->AddSubscribeTrigger(queryInner, subscribeId);
418     if (errCode != E_OK) {
419         LOGE("Add subscribe trigger failed: %d", errCode);
420         (void)handle->Rollback();
421     } else {
422         errCode = handle->Commit();
423     }
424     ReleaseHandle(handle);
425     return errCode;
426 }
427 
SetMaxLogSize(uint64_t limit)428 int SQLiteSingleVerNaturalStore::SetMaxLogSize(uint64_t limit)
429 {
430     LOGI("Set the max log size to %" PRIu64, limit);
431     maxLogSize_.store(limit);
432     return E_OK;
433 }
GetMaxLogSize() const434 uint64_t SQLiteSingleVerNaturalStore::GetMaxLogSize() const
435 {
436     return maxLogSize_.load();
437 }
438 
Dump(int fd)439 void SQLiteSingleVerNaturalStore::Dump(int fd)
440 {
441     std::string userId = MyProp().GetStringProp(DBProperties::USER_ID, "");
442     std::string appId = MyProp().GetStringProp(DBProperties::APP_ID, "");
443     std::string storeId = MyProp().GetStringProp(DBProperties::STORE_ID, "");
444     std::string label = MyProp().GetStringProp(DBProperties::IDENTIFIER_DATA, "");
445     label = DBCommon::TransferStringToHex(label);
446     DBDumpHelper::Dump(fd, "\tdb userId = %s, appId = %s, storeId = %s, label = %s\n",
447         userId.c_str(), appId.c_str(), storeId.c_str(), label.c_str());
448     SyncAbleKvDB::Dump(fd);
449 }
450 
IsSupportSubscribe() const451 int SQLiteSingleVerNaturalStore::IsSupportSubscribe() const
452 {
453     const SchemaObject &localSchema = MyProp().GetSchemaConstRef();
454     if (localSchema.GetSchemaType() != SchemaType::NONE && localSchema.GetSchemaType() != SchemaType::JSON) {
455         // Flatbuffer schema is not support subscribe
456         return -E_NOT_SUPPORT;
457     }
458     return E_OK;
459 }
460 
RemoveDeviceDataInner(const std::string & hashDev,bool isNeedNotify)461 int SQLiteSingleVerNaturalStore::RemoveDeviceDataInner(const std::string &hashDev, bool isNeedNotify)
462 {
463     int errCode = E_OK;
464     SQLiteSingleVerStorageExecutor *handle = GetHandle(true, errCode);
465     if (handle == nullptr) {
466         LOGE("[SingleVerNStore] RemoveDeviceData get handle failed:%d", errCode);
467         return errCode;
468     }
469     uint64_t logFileSize = handle->GetLogFileSize();
470     ReleaseHandle(handle);
471     if (logFileSize > GetMaxLogSize()) {
472         LOGW("[SingleVerNStore] RmDevData log size[%" PRIu64 "] over the limit", logFileSize);
473         return -E_LOG_OVER_LIMITS;
474     }
475 
476     std::set<std::string> removeDevices;
477     if (hashDev.empty()) {
478         errCode = GetExistsDeviceList(removeDevices);
479         if (errCode != E_OK) {
480             LOGE("[SingleVerNStore] get remove device list failed:%d", errCode);
481             return errCode;
482         }
483     } else {
484         removeDevices.insert(hashDev);
485     }
486 
487     LOGD("[SingleVerNStore] remove device data, size=%zu", removeDevices.size());
488     for (const auto &iterDevice : removeDevices) {
489         // Call the syncer module to erase the water mark.
490         errCode = EraseDeviceWaterMark(iterDevice, false);
491         if (errCode != E_OK) {
492             LOGE("[SingleVerNStore] erase water mark failed:%d", errCode);
493             return errCode;
494         }
495     }
496 
497     CleanAllWaterMark();
498     if (IsExtendedCacheDBMode()) {
499         errCode = RemoveDeviceDataInCacheMode(hashDev, isNeedNotify);
500     } else {
501         errCode = RemoveDeviceDataNormally(hashDev, isNeedNotify);
502     }
503     if (errCode != E_OK) {
504         LOGE("[SingleVerNStore] RemoveDeviceData failed:%d", errCode);
505     }
506 
507     return errCode;
508 }
509 
RemoveDeviceDataInner(const std::string & hashDev,ClearMode mode)510 int SQLiteSingleVerNaturalStore::RemoveDeviceDataInner(const std::string &hashDev, ClearMode mode)
511 {
512     int errCode = E_OK;
513     SQLiteSingleVerStorageExecutor *handle = GetHandle(true, errCode);
514     if (handle == nullptr) {
515         LOGE("[SingleVerNStore] RemoveDeviceData with mode get handle failed:%d", errCode);
516         return errCode;
517     }
518     errCode = handle->StartTransaction(TransactType::IMMEDIATE);
519     if (errCode != E_OK) {
520         LOGE("Start transaction failed %d in RemoveDeviceData.", errCode);
521         ReleaseHandle(handle);
522         return errCode;
523     }
524     errCode = handle->RemoveDeviceData(hashDev, mode);
525     if (errCode != E_OK) {
526         LOGE("RemoveDeviceData failed: %d", errCode);
527         (void)handle->Rollback();
528     } else {
529         errCode = handle->Commit();
530         if (errCode != E_OK) {
531             LOGE("Transaction commit failed %d in RemoveDeviceData.", errCode);
532         }
533     }
534     ReleaseHandle(handle);
535     return errCode;
536 }
537 
RemoveDeviceDataInner(const std::string & hashDev,const std::string & user,ClearMode mode)538 int SQLiteSingleVerNaturalStore::RemoveDeviceDataInner(const std::string &hashDev, const std::string &user,
539     ClearMode mode)
540 {
541     int errCode = E_OK;
542     SQLiteSingleVerStorageExecutor *handle = GetHandle(true, errCode);
543     if (handle == nullptr) {
544         LOGE("[SingleVerNStore] RemoveDeviceData with user and mode get handle failed:%d", errCode);
545         return errCode;
546     }
547     errCode = handle->StartTransaction(TransactType::IMMEDIATE);
548     if (errCode != E_OK) {
549         LOGE("Start transaction failed %d in RemoveDeviceData.", errCode);
550         ReleaseHandle(handle);
551         return errCode;
552     }
553     errCode = handle->RemoveDeviceData(hashDev, user, mode);
554     if (errCode != E_OK) {
555         LOGE("RemoveDeviceData failed: %d", errCode);
556         (void)handle->Rollback();
557     } else {
558         errCode = handle->Commit();
559         if (errCode != E_OK) {
560             LOGE("Transaction commit failed %d in RemoveDeviceData.", errCode);
561         }
562     }
563     ReleaseHandle(handle);
564     return errCode;
565 }
566 
AbortHandle()567 void SQLiteSingleVerNaturalStore::AbortHandle()
568 {
569     std::unique_lock<std::shared_mutex> lock(abortHandleMutex_);
570     abortPerm_ = OperatePerm::RESTART_SYNC_PERM;
571 }
572 
EnableHandle()573 void SQLiteSingleVerNaturalStore::EnableHandle()
574 {
575     std::unique_lock<std::shared_mutex> lock(abortHandleMutex_);
576     abortPerm_ = OperatePerm::NORMAL_PERM;
577 }
578 
TryHandle() const579 int SQLiteSingleVerNaturalStore::TryHandle() const
580 {
581     std::unique_lock<std::shared_mutex> lock(abortHandleMutex_);
582     if (abortPerm_ == OperatePerm::RESTART_SYNC_PERM) {
583         LOGW("[SingleVerNStore] Restarting sync, handle id[%s] is busy",
584             DBCommon::TransferStringToHex(storageEngine_->GetIdentifier()).c_str());
585         return -E_BUSY;
586     }
587     return E_OK;
588 }
589 
GetStorageExecutor(bool isWrite)590 std::pair<int, SQLiteSingleVerStorageExecutor*> SQLiteSingleVerNaturalStore::GetStorageExecutor(bool isWrite)
591 {
592     int errCode = E_OK;
593     SQLiteSingleVerStorageExecutor *handle = GetHandle(isWrite, errCode);
594     return {errCode, handle};
595 }
596 
RecycleStorageExecutor(SQLiteSingleVerStorageExecutor * executor)597 void SQLiteSingleVerNaturalStore::RecycleStorageExecutor(SQLiteSingleVerStorageExecutor *executor)
598 {
599     ReleaseHandle(executor);
600 }
601 
GetLocalTimeOffsetForCloud()602 TimeOffset SQLiteSingleVerNaturalStore::GetLocalTimeOffsetForCloud()
603 {
604     return GetLocalTimeOffset();
605 }
606 
RegisterObserverAction(const KvStoreObserver * observer,const ObserverAction & action)607 int SQLiteSingleVerNaturalStore::RegisterObserverAction(const KvStoreObserver *observer, const ObserverAction &action)
608 {
609     std::lock_guard<std::mutex> autoLock(cloudStoreMutex_);
610     if (sqliteCloudKvStore_ == nullptr) {
611         return -E_INTERNAL_ERROR;
612     }
613     sqliteCloudKvStore_->RegisterObserverAction(observer, action);
614     return E_OK;
615 }
616 
UnRegisterObserverAction(const KvStoreObserver * observer)617 int SQLiteSingleVerNaturalStore::UnRegisterObserverAction(const KvStoreObserver *observer)
618 {
619     std::lock_guard<std::mutex> autoLock(cloudStoreMutex_);
620     if (sqliteCloudKvStore_ == nullptr) {
621         return -E_INTERNAL_ERROR;
622     }
623     sqliteCloudKvStore_->UnRegisterObserverAction(observer);
624     return E_OK;
625 }
626 
GetCloudVersion(const std::string & device,std::map<std::string,std::string> & versionMap)627 int SQLiteSingleVerNaturalStore::GetCloudVersion(const std::string &device,
628     std::map<std::string, std::string> &versionMap)
629 {
630     std::lock_guard<std::mutex> autoLock(cloudStoreMutex_);
631     if (sqliteCloudKvStore_ == nullptr) {
632         return -E_INTERNAL_ERROR;
633     }
634     return sqliteCloudKvStore_->GetCloudVersion(device, versionMap);
635 }
636 
SetReceiveDataInterceptor(const DataInterceptor & interceptor)637 void SQLiteSingleVerNaturalStore::SetReceiveDataInterceptor(const DataInterceptor &interceptor)
638 {
639     std::unique_lock<std::shared_mutex> lock(dataInterceptorMutex_);
640     receiveDataInterceptor_ = interceptor;
641 }
642 
SetCloudSyncConfig(const CloudSyncConfig & config)643 int SQLiteSingleVerNaturalStore::SetCloudSyncConfig(const CloudSyncConfig &config)
644 {
645     std::lock_guard<std::mutex> autoLock(cloudStoreMutex_);
646     if (sqliteCloudKvStore_ == nullptr) {
647         LOGE("[SingleVerNStore] DB is null when set config");
648         return -E_INTERNAL_ERROR;
649     }
650     sqliteCloudKvStore_->SetCloudSyncConfig(config);
651     return E_OK;
652 }
653 }
654