openharmony/distributeddatamgr_datamgr_service
1
0
Fork 0
mirror of https://gitee.com/openharmony/distributeddatamgr_datamgr_service synced 2025-02-17 05:08:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

!2199 调整removeDeviceData至service

Browse Source 
Merge pull request !2199 from yanhui/removeDeviceData
This commit is contained in:
openharmony_ci 2024-08-31 12:24:28 +00:00 committed by Gitee
commit 6e57a35b00
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
7 changed files with 121 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
services/distributeddataservice/framework/include/error/general_error.h
View File

@ -41,6 +41,16 @@ enum GeneralError : int32_t {
E_SYNC_TASK_MERGED,
E_RECORD_NOT_FOUND,
E_RECORD_ALREADY_EXISTED,
E_DB_ERROR,
E_INVALID_VALUE_FIELDS,
E_INVALID_FIELD_TYPE,
E_CONSTRAIN_VIOLATION,
E_INVALID_FORMAT,
E_INVALID_QUERY_FORMAT,
E_INVALID_QUERY_FIELD,
E_TIME_OUT,
E_OVER_MAX_LIMITS,
E_SECURITY_LEVEL_ERROR,
E_BUTT,
};
}

47
services/distributeddataservice/service/kvdb/kvdb_general_store.cpp
View File

@ -37,7 +37,6 @@
#include "utils/anonymous.h"
#include "water_version_manager.h"
#include "device_manager_adapter.h"
#include "utils/anonymous.h"
#include "app_id_mapping/app_id_mapping_config_manager.h"
namespace OHOS::DistributedKv {
@ -50,6 +49,30 @@ using ClearMode = DistributedDB::ClearMode;
using DMAdapter = DistributedData::DeviceManagerAdapter;
using DBInterceptedData = DistributedDB::InterceptedData;
constexpr int UUID_WIDTH = 4;
const std::map<DBStatus, KVDBGeneralStore::GenErr> KVDBGeneralStore::dbStatusMap_ = {
{ DBStatus::OK, GenErr::E_OK },
{ DBStatus::CLOUD_NETWORK_ERROR, GenErr::E_NETWORK_ERROR },
{ DBStatus::CLOUD_LOCK_ERROR, GenErr::E_LOCKED_BY_OTHERS },
{ DBStatus::CLOUD_FULL_RECORDS, GenErr::E_RECODE_LIMIT_EXCEEDED },
{ DBStatus::CLOUD_ASSET_SPACE_INSUFFICIENT, GenErr::E_NO_SPACE_FOR_ASSET },
{ DBStatus::CLOUD_SYNC_TASK_MERGED, GenErr::E_SYNC_TASK_MERGED },
{ DBStatus::BUSY, GenErr::E_DB_ERROR },
{ DBStatus::DB_ERROR, GenErr::E_DB_ERROR },
{ DBStatus::INVALID_ARGS, GenErr::E_INVALID_ARGS },
{ DBStatus::NOT_FOUND, GenErr::E_RECORD_NOT_FOUND },
{ DBStatus::INVALID_VALUE_FIELDS, GenErr::E_INVALID_VALUE_FIELDS },
{ DBStatus::INVALID_FIELD_TYPE, GenErr::E_INVALID_FIELD_TYPE },
{ DBStatus::CONSTRAIN_VIOLATION, GenErr::E_CONSTRAIN_VIOLATION },
{ DBStatus::INVALID_FORMAT, GenErr::E_INVALID_FORMAT },
{ DBStatus::INVALID_QUERY_FORMAT, GenErr::E_INVALID_QUERY_FORMAT },
{ DBStatus::INVALID_QUERY_FIELD, GenErr::E_INVALID_QUERY_FIELD },
{ DBStatus::NOT_SUPPORT, GenErr::E_NOT_SUPPORT },
{ DBStatus::TIME_OUT, GenErr::E_TIME_OUT },
{ DBStatus::OVER_MAX_LIMITS, GenErr::E_OVER_MAX_LIMITS },
{ DBStatus::EKEYREVOKED_ERROR, GenErr::E_SECURITY_LEVEL_ERROR },
{ DBStatus::SECURITY_OPTION_CHECK_ERROR, GenErr::E_SECURITY_LEVEL_ERROR },
};
constexpr uint32_t LOCK_TIMEOUT = 3600; // second
static DBSchema GetDBSchema(const Database &database)
{
@ -477,7 +500,7 @@ int32_t KVDBGeneralStore::Clean(const std::vector<std::string> &devices, int32_t
default:
return GeneralError::E_ERROR;
}
return status == DistributedDB::OK ? GeneralError::E_OK : GeneralError::E_ERROR;
return ConvertStatus(status);
}
int32_t KVDBGeneralStore::Watch(int32_t origin, Watcher &watcher)
@ -540,23 +563,11 @@ int32_t KVDBGeneralStore::SetTrackerTable(
KVDBGeneralStore::GenErr KVDBGeneralStore::ConvertStatus(DistributedDB::DBStatus status)
{
switch (status) {
case DBStatus::OK:
return GenErr::E_OK;
case DBStatus::CLOUD_NETWORK_ERROR:
return GenErr::E_NETWORK_ERROR;
case DBStatus::CLOUD_LOCK_ERROR:
return GenErr::E_LOCKED_BY_OTHERS;
case DBStatus::CLOUD_FULL_RECORDS:
return GenErr::E_RECODE_LIMIT_EXCEEDED;
case DBStatus::CLOUD_ASSET_SPACE_INSUFFICIENT:
return GenErr::E_NO_SPACE_FOR_ASSET;
case DBStatus::CLOUD_SYNC_TASK_MERGED:
return GenErr::E_SYNC_TASK_MERGED;
default:
ZLOGI("status:0x%{public}x", status);
break;
auto it = dbStatusMap_.find(status);
if (it != dbStatusMap_.end()) {
return it->second;
}
ZLOGI("status:0x%{public}x", status);
return GenErr::E_ERROR;
}

1
services/distributeddataservice/service/kvdb/kvdb_general_store.h
View File

@ -135,6 +135,7 @@ private:
static constexpr const char *defaultAccountId = "ohosAnonymousUid";
bool enableCloud_ = false;
bool isPublic_ = false;
static const std::map<DBStatus, GenErr> dbStatusMap_;
};
} // namespace OHOS::DistributedKv
#endif // OHOS_DISTRIBUTED_DATA_DATAMGR_SERVICE_KVDB_GENERAL_STORE_H

58
services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp
View File

@ -1195,6 +1195,43 @@ Status KVDBServiceImpl::ConvertDbStatus(DBStatus status) const
return Status::ERROR;
}
Status KVDBServiceImpl::ConvertGeneralErr(GeneralError error) const
{
switch (error) {
case GeneralError::E_DB_ERROR:
return Status::DB_ERROR;
case GeneralError::E_OK:
return Status::SUCCESS;
case GeneralError::E_INVALID_ARGS:
return Status::INVALID_ARGUMENT;
case GeneralError::E_RECORD_NOT_FOUND:
return Status::KEY_NOT_FOUND;
case GeneralError::E_INVALID_VALUE_FIELDS:
return Status::INVALID_VALUE_FIELDS;
case GeneralError::E_INVALID_FIELD_TYPE:
return Status::INVALID_FIELD_TYPE;
case GeneralError::E_CONSTRAIN_VIOLATION:
return Status::CONSTRAIN_VIOLATION;
case GeneralError::E_INVALID_FORMAT:
return Status::INVALID_FORMAT;
case GeneralError::E_INVALID_QUERY_FORMAT:
return Status::INVALID_QUERY_FORMAT;
case GeneralError::E_INVALID_QUERY_FIELD:
return Status::INVALID_QUERY_FIELD;
case GeneralError::E_NOT_SUPPORT:
return Status::NOT_SUPPORT;
case GeneralError::E_TIME_OUT:
return Status::TIME_OUT;
case GeneralError::E_OVER_MAX_LIMITS:
return Status::OVER_MAX_LIMITS;
case GeneralError::E_SECURITY_LEVEL_ERROR:
return Status::SECURITY_LEVEL_ERROR;
default:
break;
}
return Status::ERROR;
}
KVDBServiceImpl::DBMode KVDBServiceImpl::ConvertDBMode(SyncMode syncMode) const
{
DBMode dbMode;
@ -1334,4 +1371,25 @@ bool KVDBServiceImpl::IsOHOSType(const std::vector<std::string> &ids)
}
return isOHOSType;
}
Status KVDBServiceImpl::RemoveDeviceData(const AppId &appId, const StoreId &storeId, const std::string &device)
{
StoreMetaData metaData = GetStoreMetaData(appId, storeId);
MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData);
auto watcher = GetWatchers(metaData.tokenId, metaData.storeId);
auto store = AutoCache::GetInstance().GetStore(metaData, watcher);
if (store == nullptr) {
ZLOGE("GetStore failed! appId:%{public}s storeId:%{public}s dir:%{public}s", metaData.bundleName.c_str(),
Anonymous::Change(metaData.storeId).c_str(), metaData.dataDir.c_str());
return Status::ERROR;
}
int32_t ret;
if (device.empty()) {
ret = store->Clean({}, KVDBGeneralStore::NEARBY_DATA, "");
} else {
ret = store->Clean({ DMAdapter::GetInstance().ToUUID(device) }, KVDBGeneralStore::NEARBY_DATA, "");
}
return ConvertGeneralErr(GeneralError(ret));
}
} // namespace OHOS::DistributedKv

3
services/distributeddataservice/service/kvdb/kvdb_service_impl.h
View File

@ -73,6 +73,7 @@ public:
int32_t OnAppExit(pid_t uid, pid_t pid, uint32_t tokenId, const std::string &appId) override;
int32_t ResolveAutoLaunch(const std::string &identifier, DBLaunchParam &param) override;
int32_t OnUserChange(uint32_t code, const std::string &user, const std::string &account) override;
Status RemoveDeviceData(const AppId &appId, const StoreId &storeId, const std::string &device) override;
private:
using StoreMetaData = OHOS::DistributedData::StoreMetaData;
@ -86,6 +87,7 @@ private:
using DBStatus = DistributedDB::DBStatus;
using DBMode = DistributedDB::SyncMode;
using Action = OHOS::DistributedData::MetaDataManager::Action;
using GeneralError = DistributedData::GeneralError;
enum SyncAction {
ACTION_SYNC,
ACTION_SUBSCRIBE,
@ -126,6 +128,7 @@ private:
Status DoComplete(const StoreMetaData &meta, const SyncInfo &info, RefCount refCount, const DBResult &dbResult);
uint32_t GetSyncDelayTime(uint32_t delay, const StoreId &storeId);
Status ConvertDbStatus(DBStatus status) const;
Status ConvertGeneralErr(GeneralError error) const;
DBMode ConvertDBMode(SyncMode syncMode) const;
ChangeType ConvertType(SyncMode syncMode) const;
SwitchState ConvertAction(Action action) const;

20
services/distributeddataservice/service/kvdb/kvdb_service_stub.cpp
View File

@ -49,6 +49,7 @@ const KVDBServiceStub::Handler
&KVDBServiceStub::OnSubscribeSwitchData,
&KVDBServiceStub::OnUnsubscribeSwitchData,
&KVDBServiceStub::OnClose,
&KVDBServiceStub::OnRemoveDeviceData,
};
int KVDBServiceStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply)
@ -107,7 +108,7 @@ std::pair<int32_t, KVDBServiceStub::StoreInfo> KVDBServiceStub::GetStoreInfo(uin
bool KVDBServiceStub::CheckPermission(uint32_t code, const StoreInfo &storeInfo)
{
if (code >= static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_PUT_SWITCH) &&
code < static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_BUTT)) {
code <= static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_UNSUBSCRIBE_SWITCH_DATA)) {
return CheckerManager::GetInstance().IsSwitches(storeInfo);
}
return CheckerManager::GetInstance().IsValid(storeInfo);
@ -505,4 +506,21 @@ int32_t KVDBServiceStub::OnSetConfig(const AppId &appId, const StoreId &storeId,
}
return ERR_NONE;
}
int32_t KVDBServiceStub::OnRemoveDeviceData(const AppId &appId, const StoreId &storeId, MessageParcel &data,
MessageParcel &reply)
{
std::string device;
if (!ITypesUtil::Unmarshal(data, device)) {
ZLOGE("Unmarshal appId:%{public}s storeId:%{public}s", appId.appId.c_str(),
Anonymous::Change(storeId.storeId).c_str());
return IPC_STUB_INVALID_DATA_ERR;
}
int32_t status = RemoveDeviceData(appId, storeId, device);
if (!ITypesUtil::Marshal(reply, status)) {
ZLOGE("Marshal status:0x%{public}x appId:%{public}s", status, appId.appId.c_str());
return IPC_STUB_WRITE_PARCEL_ERR;
}
return ERR_NONE;
}
} // namespace OHOS::DistributedKv

1
services/distributeddataservice/service/kvdb/kvdb_service_stub.h
View File

@ -58,6 +58,7 @@ private:
int32_t OnUnsubscribeSwitchData(const AppId &appId, const StoreId &storeId, MessageParcel &data,
MessageParcel &reply);
int32_t OnSetConfig(const AppId &appId, const StoreId &storeId, MessageParcel &data, MessageParcel &reply);
int32_t OnRemoveDeviceData(const AppId &appId, const StoreId &storeId, MessageParcel &data, MessageParcel &reply);
static const Handler HANDLERS[static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_BUTT)];
bool CheckPermission(uint32_t code, const StoreInfo &storeInfo);