openharmony/communication_dsoftbus
1
0
Fork 0
mirror of https://gitee.com/openharmony/communication_dsoftbus synced 2025-02-17 17:49:15 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

!6206 refine cloud sync logs

Browse Source 
Merge pull request !6206 from 刘宝/dev_refine
This commit is contained in:
openharmony_ci 2024-05-23 09:29:22 +00:00 committed by Gitee
commit 895d59730c
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
6 changed files with 128 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
core/adapter/bus_center/include/lnn_kv_adapter_wrapper.h
View File

@ -1,17 +1,17 @@
/*
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef DSOFTBUS_KV_STORE_LNN_KV_ADAPTER_WRAPPER_H
#define DSOFTBUS_KV_STORE_LNN_KV_ADAPTER_WRAPPER_H
@ -21,8 +21,7 @@
extern "C" {
#endif
int32_t LnnCreateKvAdapter(int32_t *dbId, const char *appId, int32_t appIdLen, const char *storeId,
int32_t storeIdLen);
int32_t LnnCreateKvAdapter(int32_t *dbId, const char *appId, int32_t appIdLen, const char *storeId, int32_t storeIdLen);
int32_t LnnDestroyKvAdapter(int32_t dbId);
int32_t LnnPutDBData(int32_t dbId, const char *key, int32_t keyLen, const char *value, int32_t valueLen);
int32_t LnnPutDBDataBatch(int32_t dbId, const CloudSyncInfo *localInfo);
@ -35,4 +34,4 @@ int32_t LnnCloudSync(int32_t dbId);
};
#endif
#endif //DSOFTBUS_KV_STORE_LNN_KV_ADAPTER_WRAPPER_H
#endif // DSOFTBUS_KV_STORE_LNN_KV_ADAPTER_WRAPPER_H

120
core/adapter/bus_center/src/lnn_kv_adapter_wrapper.cpp
View File

@ -1,26 +1,27 @@
/*
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <string>
#include <cstring>
#include <string>
#include "lnn_kv_adapter_wrapper.h"
#include "lnn_log.h"
#include "softbus_errcode.h"
#include "lnn_device_info_recovery.h"
#include "lnn_kv_adapter.h"
#include "lnn_kv_data_change_listener.h"
#include "lnn_device_info_recovery.h"
#include "lnn_log.h"
#include "softbus_errcode.h"
using namespace OHOS;
using namespace OHOS::DistributedKv;
@ -30,16 +31,15 @@ constexpr int32_t MAX_STRING_LEN = 4096;
constexpr int32_t MIN_STRING_LEN = 1;
const std::string SEPARATOR = "#";
std::mutex g_kvAdapterWrapperMutex;
}
} // namespace
static int32_t g_dbId = 1;
static std::map<int32_t, std::shared_ptr<OHOS::KVAdapter>> g_dbID2KvAdapter;
void BasicCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::string, std::string>& values);
void ComplexCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::string, std::string>& values);
std::shared_ptr<OHOS::KVAdapter> FindKvStorePtr(int32_t& dbId);
void BasicCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::string, std::string> &values);
void ComplexCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::string, std::string> &values);
std::shared_ptr<OHOS::KVAdapter> FindKvStorePtr(int32_t &dbId);
int32_t LnnCreateKvAdapter(int32_t *dbId, const char *appId, int32_t appIdLen, const char *storeId,
int32_t storeIdLen)
int32_t LnnCreateKvAdapter(int32_t *dbId, const char *appId, int32_t appIdLen, const char *storeId, int32_t storeIdLen)
{
if (dbId == nullptr || appId == nullptr || appIdLen < MIN_STRING_LEN || appIdLen > MAX_STRING_LEN ||
storeId == nullptr || storeIdLen < MIN_STRING_LEN || storeIdLen > MAX_STRING_LEN) {
@ -50,18 +50,17 @@ int32_t LnnCreateKvAdapter(int32_t *dbId, const char *appId, int32_t appIdLen, c
std::shared_ptr<KVAdapter> kvAdapter = nullptr;
{
std::lock_guard<std::mutex> lock(g_kvAdapterWrapperMutex);
kvAdapter = std::make_shared<KVAdapter>(appIdStr, storeIdStr,
std::make_shared<KvDataChangeListener>());
kvAdapter = std::make_shared<KVAdapter>(appIdStr, storeIdStr, std::make_shared<KvDataChangeListener>());
int32_t initRet = kvAdapter->Init();
if (initRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter init failed, ret = %{public}d", initRet);
LNN_LOGE(LNN_LEDGER, "kvAdapter init failed, ret=%{public}d", initRet);
return initRet;
}
*dbId = g_dbId;
*dbId=g_dbId;
g_dbID2KvAdapter.insert(std::make_pair(g_dbId, kvAdapter));
g_dbId++;
}
LNN_LOGI(LNN_LEDGER, "kvAdapter init success, dbId = %{public}d", *dbId);
LNN_LOGI(LNN_LEDGER, "kvAdapter init success, dbId=%{public}d", *dbId);
return SOFTBUS_OK;
}
@ -75,20 +74,20 @@ int32_t LnnDestroyKvAdapter(int32_t dbId)
}
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId=%{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
unInitRet = kvAdapter->DeInit();
}
if (unInitRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter unInit failed, ret = %{public}d", unInitRet);
LNN_LOGE(LNN_LEDGER, "kvAdapter unInit failed, ret=%{public}d", unInitRet);
return unInitRet;
}
{
std::lock_guard<std::mutex> lock(g_kvAdapterWrapperMutex);
g_dbID2KvAdapter.erase(dbId);
}
LNN_LOGI(LNN_LEDGER, "kvAdapter unInit success, dbId = %{public}d", dbId);
LNN_LOGI(LNN_LEDGER, "kvAdapter unInit success, dbId=%{public}d", dbId);
return SOFTBUS_OK;
}
@ -96,7 +95,7 @@ std::shared_ptr<KVAdapter> FindKvStorePtr(int32_t &dbId)
{
auto iter = g_dbID2KvAdapter.find(dbId);
if (iter == g_dbID2KvAdapter.end()) {
LNN_LOGE(LNN_LEDGER, "dbID is not exist, dbId = %{public}d", dbId);
LNN_LOGE(LNN_LEDGER, "dbID is not exist, dbId=%{public}d", dbId);
return nullptr;
}
return iter->second;
@ -107,25 +106,24 @@ int32_t LnnPutDBData(int32_t dbId, const char *key, int32_t keyLen, const char *
int32_t putRet;
{
std::lock_guard<std::mutex> lock(g_kvAdapterWrapperMutex);
if (key == nullptr || keyLen < MIN_STRING_LEN || keyLen > MAX_STRING_LEN ||
value == nullptr || valueLen < MIN_STRING_LEN || valueLen > MAX_STRING_LEN ||
dbId < MIN_DBID_COUNT || dbId >= g_dbId) {
if (key == nullptr || keyLen < MIN_STRING_LEN || keyLen > MAX_STRING_LEN || value == nullptr ||
valueLen < MIN_STRING_LEN || valueLen > MAX_STRING_LEN || dbId < MIN_DBID_COUNT || dbId >= g_dbId) {
return SOFTBUS_INVALID_PARAM;
}
std::string keyStr(key, keyLen);
std::string valueStr(value, valueLen);
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId=%{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
putRet = kvAdapter->Put(keyStr, valueStr);
}
if (putRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter put failed, ret = %{public}d", putRet);
LNN_LOGE(LNN_LEDGER, "kvAdapter put failed, ret=%{public}d", putRet);
return putRet;
}
LNN_LOGI(LNN_LEDGER, "kvAdapter put success, dbId = %{public}d", dbId);
LNN_LOGI(LNN_LEDGER, "kvAdapter put success, dbId=%{public}d", dbId);
return SOFTBUS_OK;
}
@ -134,23 +132,23 @@ int32_t LnnDeleteDBData(int32_t dbId, const char *key, int32_t keyLen)
int32_t deleteRet;
{
std::lock_guard<std::mutex> lock(g_kvAdapterWrapperMutex);
if (key == nullptr || keyLen < MIN_STRING_LEN || keyLen > MAX_STRING_LEN ||
dbId < MIN_DBID_COUNT || dbId >= g_dbId) {
if (key == nullptr || keyLen < MIN_STRING_LEN || keyLen > MAX_STRING_LEN || dbId < MIN_DBID_COUNT ||
dbId >= g_dbId) {
return SOFTBUS_INVALID_PARAM;
}
std::string keyStr(key, keyLen);
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId=%{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
deleteRet = kvAdapter->Delete(keyStr);
}
if (deleteRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter delete failed, ret = %{public}d", deleteRet);
LNN_LOGE(LNN_LEDGER, "kvAdapter delete failed, ret=%{public}d", deleteRet);
return deleteRet;
}
LNN_LOGI(LNN_LEDGER, "kvAdapter delete success, dbId = %{public}d", dbId);
LNN_LOGI(LNN_LEDGER, "kvAdapter delete success, dbId=%{public}d", dbId);
return SOFTBUS_OK;
}
@ -167,13 +165,13 @@ int32_t LnnGetDBData(int32_t dbId, const char *key, int32_t keyLen, char **value
std::string keyStr(key, keyLen);
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId=%{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
getRet = kvAdapter->Get(keyStr, valueStr);
}
if (getRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter get failed, ret = %{public}d", getRet);
LNN_LOGE(LNN_LEDGER, "kvAdapter get failed, ret=%{public}d", getRet);
return getRet;
}
*value = strdup(valueStr.c_str());
@ -181,7 +179,7 @@ int32_t LnnGetDBData(int32_t dbId, const char *key, int32_t keyLen, char **value
LNN_LOGE(LNN_LEDGER, "strdup failed");
return SOFTBUS_MALLOC_ERR;
}
LNN_LOGI(LNN_LEDGER, "kvAdapter get success, dbId = %{public}d", dbId);
LNN_LOGI(LNN_LEDGER, "kvAdapter get success, dbId=%{public}d", dbId);
return SOFTBUS_OK;
}
@ -197,16 +195,16 @@ int32_t LnnDeleteDBDataByPrefix(int32_t dbId, const char *keyPrefix, int32_t key
std::string keyPrefixStr(keyPrefix, keyPrefixLen);
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId=%{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
deleteRet = kvAdapter->DeleteByPrefix(keyPrefixStr);
}
if (deleteRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter delete failed, ret = %{public}d", deleteRet);
LNN_LOGE(LNN_LEDGER, "kvAdapter delete failed, ret=%{public}d", deleteRet);
return deleteRet;
}
LNN_LOGI(LNN_LEDGER, "kvAdapter delete success, dbId = %{public}d", dbId);
LNN_LOGI(LNN_LEDGER, "kvAdapter delete success, dbId=%{public}d", dbId);
return SOFTBUS_OK;
}
@ -223,16 +221,16 @@ int32_t LnnPutDBDataBatch(int32_t dbId, const CloudSyncInfo *localInfo)
ComplexCloudSyncInfoToMap(localInfo, values);
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId=%{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
putBatchRet = kvAdapter->PutBatch(values);
}
if (putBatchRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter putBatch failed, ret = %{public}d", putBatchRet);
LNN_LOGE(LNN_LEDGER, "kvAdapter putBatch failed, ret=%{public}d", putBatchRet);
return putBatchRet;
}
LNN_LOGI(LNN_LEDGER, "kvAdapter putBatch success, dbId = %{public}d", dbId);
LNN_LOGI(LNN_LEDGER, "kvAdapter putBatch success, dbId=%{public}d", dbId);
return SOFTBUS_OK;
}
@ -245,13 +243,13 @@ int32_t LnnCloudSync(int32_t dbId)
}
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId=%{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
return (kvAdapter->CloudSync());
}
void BasicCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::string, std::string>& values)
void BasicCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::string, std::string> &values)
{
if (localInfo == nullptr) {
LNN_LOGE(LNN_LEDGER, "localInfo is null");
@ -270,8 +268,8 @@ void BasicCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::strin
values[keyPrefix + DEVICE_INFO_DEVICE_UUID] = localInfo->uuid + stateVersionStr;
values[keyPrefix + DEVICE_INFO_SW_VERSION] = localInfo->softBusVersion + stateVersionStr;
values[keyPrefix + DEVICE_INFO_BLE_P2P] = (localInfo->isBleP2p ? "true" : "false") + stateVersionStr;
values[keyPrefix + DEVICE_INFO_TRANSPORT_PROTOCOL] = std::to_string(localInfo->supportedProtocols) +
stateVersionStr;
values[keyPrefix + DEVICE_INFO_TRANSPORT_PROTOCOL] =
std::to_string(localInfo->supportedProtocols) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_PKG_VERSION] = localInfo->pkgVersion + stateVersionStr;
values[keyPrefix + DEVICE_INFO_WIFI_VERSION] = std::to_string(localInfo->wifiVersion) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_BLE_VERSION] = std::to_string(localInfo->bleVersion) + stateVersionStr;
@ -286,7 +284,7 @@ void BasicCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::strin
values[keyPrefix + DEVICE_INFO_P2P_MAC_ADDR] = localInfo->p2pMac + stateVersionStr;
}
void ComplexCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::string, std::string>& values)
void ComplexCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::string, std::string> &values)
{
if (localInfo == nullptr) {
LNN_LOGE(LNN_LEDGER, "localInfo is null");
@ -308,8 +306,8 @@ void ComplexCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::str
values[keyPrefix + DEVICE_INFO_PTK] = localInfo->remotePtk + stateVersionStr;
values[keyPrefix + DEVICE_INFO_JSON_KEY_TABLE_MIAN] = localInfo->tableMain + stateVersionStr;
values[keyPrefix + DEVICE_INFO_JSON_KEY_TOTAL_LIFE] = std::to_string(localInfo->lifeTotal) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_JSON_KEY_TIMESTAMP_BEGIN] = std::to_string(localInfo->curBeginTime) +
stateVersionStr;
values[keyPrefix + DEVICE_INFO_JSON_KEY_TIMESTAMP_BEGIN] =
std::to_string(localInfo->curBeginTime) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_JSON_KEY_CURRENT_INDEX] = std::to_string(localInfo->currentIndex) + stateVersionStr;
char cipherKeyStr[SESSION_KEY_LENGTH];
for (int32_t i = 0; i < SESSION_KEY_LENGTH; i++) {
@ -321,6 +319,6 @@ void ComplexCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::str
cipherIvStr[i] = static_cast<char>(localInfo->cipherIv[i]);
}
values[keyPrefix + DEVICE_INFO_BROADCAST_CIPHER_IV] = cipherIvStr + stateVersionStr;
values[keyPrefix + DEVICE_INFO_DISTRIBUTED_SWITCH] = (localInfo->distributedSwitch ? "true" : "false") +
stateVersionStr;
values[keyPrefix + DEVICE_INFO_DISTRIBUTED_SWITCH] =
(localInfo->distributedSwitch ? "true" : "false") + stateVersionStr;
}

30
core/adapter/bus_center/src/lnn_kv_adapter_wrapper_virtual.cpp
View File

@ -1,22 +1,22 @@
/*
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "lnn_kv_adapter_wrapper.h"
#include "softbus_errcode.h"
int32_t LnnCreateKvAdapter(int32_t *dbId, const char *appId, int32_t appIdLen, const char *storeId,
int32_t storeIdLen)
int32_t LnnCreateKvAdapter(int32_t *dbId, const char *appId, int32_t appIdLen, const char *storeId, int32_t storeIdLen)
{
(void)dbId;
(void)appId;

20
core/adapter/kv_store/src/lnn_kv_adapter.cpp
View File

@ -104,7 +104,7 @@ int32_t KVAdapter::RegisterDataChangeListener()
DistributedKv::Status status =
kvStorePtr_->SubscribeKvStore(DistributedKv::SubscribeType::SUBSCRIBE_TYPE_CLOUD, dataChangeListener_);
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "Register db data change listener failed, ret: %{public}d", status);
LNN_LOGE(LNN_LEDGER, "Register db data change listener failed, ret=%{public}d", status);
return SOFTBUS_KV_REGISTER_DATA_LISTENER_FAILED;
}
}
@ -127,7 +127,7 @@ int32_t KVAdapter::UnRegisterDataChangeListener()
DistributedKv::Status status =
kvStorePtr_->UnSubscribeKvStore(DistributedKv::SubscribeType::SUBSCRIBE_TYPE_CLOUD, dataChangeListener_);
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "UnRegister db data change listener failed, ret: %{public}d", status);
LNN_LOGE(LNN_LEDGER, "UnRegister db data change listener failed, ret=%{public}d", status);
return SOFTBUS_KV_UNREGISTER_DATA_LISTENER_FAILED;
}
}
@ -174,7 +174,7 @@ int32_t KVAdapter::Put(const std::string &key, const std::string &value)
status = kvStorePtr_->Put(kvKey, kvValue);
}
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "Put kv to db failed, ret: %{public}d", status);
LNN_LOGE(LNN_LEDGER, "Put kv to db failed, ret=%{public}d", status);
return SOFTBUS_KV_PUT_DB_FAIL;
}
LNN_LOGI(LNN_LEDGER, "KVAdapter Put succeed");
@ -222,7 +222,7 @@ int32_t KVAdapter::PutBatch(const std::map<std::string, std::string> &values)
status = kvStorePtr_->PutBatch(entries);
}
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "PutBatch kv to db failed, ret: %d", status);
LNN_LOGE(LNN_LEDGER, "PutBatch kv to db failed, ret=%d", status);
return SOFTBUS_KV_PUT_DB_FAIL;
}
LNN_LOGI(LNN_LEDGER, "KVAdapter PutBatch succeed");
@ -266,7 +266,7 @@ int32_t KVAdapter::DeleteByPrefix(const std::string &keyPrefix)
std::vector<DistributedKv::Entry> allEntries;
DistributedKv::Status status = kvStorePtr_->GetEntries(allEntryKeyPrefix, allEntries);
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "GetEntries failed, ret: %{public}d", status);
LNN_LOGE(LNN_LEDGER, "GetEntries failed, ret=%{public}d", status);
return SOFTBUS_KV_DEL_DB_FAIL;
}
std::vector<DistributedKv::Key> keys;
@ -275,7 +275,7 @@ int32_t KVAdapter::DeleteByPrefix(const std::string &keyPrefix)
}
status = kvStorePtr_->DeleteBatch(keys);
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "DeleteBatch failed, ret: %{public}d", status);
LNN_LOGE(LNN_LEDGER, "DeleteBatch failed, ret=%{public}d", status);
return SOFTBUS_KV_DEL_DB_FAIL;
}
LNN_LOGI(LNN_LEDGER, "DeleteByPrefix succeed");
@ -307,7 +307,7 @@ int32_t KVAdapter::Get(const std::string &key, std::string &value)
return SOFTBUS_KV_GET_DB_FAIL;
}
value = kvValue.ToString();
LNN_LOGI(LNN_LEDGER, "Get succeed");
LNN_LOGD(LNN_LEDGER, "Get succeed");
return SOFTBUS_OK;
}
@ -371,14 +371,14 @@ int32_t KVAdapter::CloudSync()
status = kvStorePtr_->CloudSync(callback);
}
if (status == DistributedKv::Status::CLOUD_DISABLED) {
LNN_LOGE(LNN_LEDGER, "cloud sync disabled, ret: %{public}d", status);
LNN_LOGE(LNN_LEDGER, "cloud sync disabled, ret=%{public}d", status);
return SOFTBUS_KV_CLOUD_DISABLED;
}
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "cloud sync failed, ret: %{public}d", status);
LNN_LOGE(LNN_LEDGER, "cloud sync failed, ret=%{public}d", status);
return SOFTBUS_KV_CLOUD_SYNC_FAIL;
}
LNN_LOGI(LNN_LEDGER, "cloud sync ok, ret: %{public}d", status);
LNN_LOGI(LNN_LEDGER, "cloud sync ok, ret=%{public}d", status);
return SOFTBUS_OK;
}

2
core/adapter/kv_store/src/lnn_kv_data_change_listener.cpp
View File

@ -73,10 +73,10 @@ void KvDataChangeListener::OnChange(const DistributedKv::DataOrigin &origin, Key
std::vector<DistributedKv::Entry> KvDataChangeListener::ConvertCloudChangeDataToEntries(
const std::vector<std::string> &keys)
{
LNN_LOGI(LNN_LEDGER, "call!");
int32_t dbId = 0;
char *anonyKey = nullptr;
LnnCreateKvAdapter(&dbId, APP_ID.c_str(), APP_ID_LEN, STORE_ID.c_str(), STORE_ID_LEN);
LNN_LOGI(LNN_LEDGER, "call! dbId=%{public}d", dbId);
std::vector<DistributedKv::Entry> entries;
if (keys.empty()) {
LNN_LOGE(LNN_LEDGER, "keys empty");

50
core/bus_center/lnn/net_builder/src/lnn_data_cloud_sync.c
View File

@ -217,7 +217,7 @@ static int32_t DBCipherInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, con
LNN_LOGE(LNN_BUILDER, "fail:cipher info %{public}s valuelength over range", fieldName);
return SOFTBUS_INVALID_PARAM;
}
LNN_LOGI(LNN_BUILDER, "DBCipherInfoSyncToCache success.");
LNN_LOGI(LNN_BUILDER, "success.");
return SOFTBUS_OK;
}
@ -275,7 +275,7 @@ static int32_t DBDeviceBasicInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName
LNN_LOGE(LNN_BUILDER, "fail:DB device name info sync to cache fail");
return SOFTBUS_ERR;
}
LNN_LOGI(LNN_BUILDER, "DBDeviceBasicInfoSyncToCache success.");
LNN_LOGI(LNN_BUILDER, "success.");
return SOFTBUS_OK;
}
@ -283,6 +283,7 @@ static int32_t DBNumInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, const
{
if (strcmp(fieldName, DEVICE_INFO_STATE_VERSION) == 0) {
cacheInfo->stateVersion = atoi(value);
LNN_LOGI(LNN_BUILDER, "success. stateVersion=%{public}d", cacheInfo->stateVersion);
} else if (strcmp(fieldName, DEVICE_INFO_TRANSPORT_PROTOCOL) == 0) {
cacheInfo->supportedProtocols = atoll(value);
} else if (strcmp(fieldName, DEVICE_INFO_WIFI_VERSION) == 0) {
@ -293,12 +294,15 @@ static int32_t DBNumInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, const
cacheInfo->accountId = atoll(value);
} else if (strcmp(fieldName, DEVICE_INFO_FEATURE) == 0) {
cacheInfo->feature = atoll(value);
LNN_LOGI(LNN_BUILDER, "success. feature=%{public}" PRIu64 "", cacheInfo->feature);
} else if (strcmp(fieldName, DEVICE_INFO_CONN_SUB_FEATURE) == 0) {
cacheInfo->connSubFeature = atoll(value);
LNN_LOGI(LNN_BUILDER, "success. connSubFeature=%{public}" PRIu64 "", cacheInfo->connSubFeature);
} else if (strcmp(fieldName, DEVICE_INFO_AUTH_CAP) == 0) {
cacheInfo->authCapacity = atoi(value);
LNN_LOGI(LNN_BUILDER, "success. authCapacity=%{public}u", cacheInfo->authCapacity);
}
LNN_LOGI(LNN_BUILDER, "DBNumInfoSyncToCache success.");
LNN_LOGD(LNN_BUILDER, "success.");
return SOFTBUS_OK;
}
@ -339,6 +343,10 @@ static int32_t DBConnectInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, co
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s networkid fail");
return SOFTBUS_STRCPY_ERR;
}
char *anonyNetworkId = NULL;
Anonymize(cacheInfo->networkId, &anonyNetworkId);
LNN_LOGI(LNN_BUILDER, "success. networkId=%{public}s", anonyNetworkId);
AnonymizeFree(anonyNetworkId);
} else if (strcmp(fieldName, DEVICE_INFO_PKG_VERSION) == 0 && valueLength < VERSION_MAX_LEN) {
if (strcpy_s(cacheInfo->pkgVersion, VERSION_MAX_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s pkgVersion fail");
@ -358,7 +366,7 @@ static int32_t DBConnectInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, co
LNN_LOGE(LNN_BUILDER, "fail:DB ConnectMacInfo Sync To Cache fail");
return SOFTBUS_ERR;
}
LNN_LOGI(LNN_BUILDER, "DBConnectInfoSyncToCache success.");
LNN_LOGD(LNN_BUILDER, "success.");
return SOFTBUS_OK;
}
@ -535,7 +543,7 @@ static int32_t SplitString(char splitKey[SPLIT_KEY_NUM][SPLIT_MAX_LEN], char spl
static int32_t HandleDBAddChangeInternal(const char *key, const char *value, NodeInfo *cacheInfo)
{
LNN_LOGI(LNN_BUILDER, "HandleDBAddChangeInternal enter.");
LNN_LOGI(LNN_BUILDER, "enter.");
if (key == NULL || value == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return SOFTBUS_INVALID_PARAM;
@ -640,7 +648,7 @@ static int32_t SetDBDataToDistributedLedger(NodeInfo *cacheInfo, char *deviceUdi
static void UpdateInfoToLedger(NodeInfo *cacheInfo, char *deviceUdid, char *fieldName, char *value)
{
LNN_LOGI(LNN_BUILDER, "UpdateInfoToLedger enter");
LNN_LOGI(LNN_BUILDER, "enter");
if (cacheInfo == NULL || deviceUdid == NULL || strlen(deviceUdid) > UDID_BUF_LEN - 1 || fieldName == NULL ||
value == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
@ -688,8 +696,8 @@ static int32_t HandleDBUpdateInternal(
if (cacheInfo.stateVersion > stateVersion && stateVersion != 1) {
return SOFTBUS_OK;
}
LNN_LOGI(
LNN_BUILDER, "update peer localStateVersion=%{public}d->%{public}d", cacheInfo.stateVersion, localStateVersion);
LNN_LOGI(LNN_BUILDER, "update peer stateVersion=%{public}d->%{public}d, localStateVersion=%{public}d->%{public}d",
cacheInfo.stateVersion, stateVersion, cacheInfo.localStateVersion, localStateVersion);
cacheInfo.stateVersion = stateVersion;
UpdateInfoToLedger(&cacheInfo, deviceUdid, fieldName, trueValue);
cacheInfo.localStateVersion = localStateVersion;
@ -779,7 +787,7 @@ static int32_t HandleDBDeleteChangeInternal(const char *key, const char *value)
LnnDeleteDeviceInfo(deviceUdid);
LnnRemoveNode(deviceUdid);
LNN_LOGI(LNN_BUILDER, "HandleDBDeleteChangeInternal success");
LNN_LOGI(LNN_BUILDER, "success");
return SOFTBUS_OK;
}
@ -823,7 +831,7 @@ int32_t LnnDBDataAddChangeSyncToCache(const char **key, const char **value, int3
FreeKeyAndValue(key, value, keySize);
(void)LnnSaveRemoteDeviceInfo(&cacheInfo);
LNN_LOGI(LNN_BUILDER, "LnnDBDataAddChangeSyncToCache success. stateVersion=%{public}d", cacheInfo.stateVersion);
LNN_LOGI(LNN_BUILDER, "success. stateVersion=%{public}d", cacheInfo.stateVersion);
if (LnnUpdateDistributedNodeInfo(&cacheInfo, cacheInfo.deviceInfo.deviceUdid) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:Cache info add sync to Ledger fail");
return SOFTBUS_ERR;
@ -857,7 +865,7 @@ int32_t LnnDBDataChangeSyncToCache(const char *key, const char *value, ChangeTyp
LNN_LOGE(LNN_BUILDER, "changeType is invalid");
return SOFTBUS_INVALID_PARAM;
}
LNN_LOGI(LNN_BUILDER, "LnnDBDataChangeSyncToCache success.");
LNN_LOGI(LNN_BUILDER, "success.");
return SOFTBUS_OK;
}
@ -891,7 +899,7 @@ int32_t LnnLedgerDataChangeSyncToDB(const char *key, const char *value, size_t v
int32_t dbId = g_dbId;
int32_t ret = LnnPutDBData(dbId, putKey, strlen(putKey), putValue, strlen(putValue));
if (ret != 0) {
LNN_LOGE(LNN_BUILDER, "fail:data sync to DB fail, errorcode: %{public}d", ret);
LNN_LOGE(LNN_BUILDER, "fail:data sync to DB fail, errorcode=%{public}d", ret);
return ret;
}
LNN_LOGI(LNN_BUILDER, "Lnn ledger %{public}s change sync to DB success. stateVersion=%{public}d", key,
@ -899,7 +907,7 @@ int32_t LnnLedgerDataChangeSyncToDB(const char *key, const char *value, size_t v
ret = LnnCloudSync(dbId);
if (ret != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:data change cloud sync fail, errorcode:%{public}d", ret);
LNN_LOGE(LNN_BUILDER, "fail:data change cloud sync fail, errorcode=%{public}d", ret);
return ret;
}
return SOFTBUS_OK;
@ -925,18 +933,16 @@ int32_t LnnLedgerAllDataSyncToDB(const NodeInfo *info)
LNN_LOGE(LNN_BUILDER, "get broadcastcipherinfo fail");
return SOFTBUS_ERR;
}
int32_t dbId = g_dbId;
int32_t ret = LnnPutDBDataBatch(dbId, &syncInfo);
if (ret != 0) {
LNN_LOGE(LNN_BUILDER, "fail:data batch sync to DB fail, errorcode:%{public}d", ret);
LNN_LOGE(LNN_BUILDER, "fail:data batch sync to DB fail, errorcode=%{public}d", ret);
return ret;
}
LNN_LOGI(LNN_BUILDER, "LnnLedgerAllDataSyncToDB success. stateVersion=%{public}d", syncInfo.stateVersion);
LNN_LOGI(LNN_BUILDER, "success. stateVersion=%{public}d", syncInfo.stateVersion);
ret = LnnCloudSync(dbId);
if (ret != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:data batch cloud sync fail, errorcode:%{public}d", ret);
LNN_LOGE(LNN_BUILDER, "fail:data batch cloud sync fail, errorcode=%{public}d", ret);
return ret;
}
return SOFTBUS_OK;
@ -961,10 +967,10 @@ int32_t LnnDeleteSyncToDB(void)
LNN_LOGE(LNN_BUILDER, "fail:data delete sync to DB fail");
return ret;
}
LNN_LOGI(LNN_BUILDER, "LnnDeleteSyncToDB success.");
LNN_LOGI(LNN_BUILDER, "success.");
ret = LnnCloudSync(dbId);
if (ret != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:data delete cloud sync fail, errorcode:%{public}d", ret);
LNN_LOGE(LNN_BUILDER, "fail:data delete cloud sync fail, errorcode=%{public}d", ret);
return ret;
}
return SOFTBUS_OK;
@ -972,7 +978,7 @@ int32_t LnnDeleteSyncToDB(void)
void LnnInitCloudSyncModule(void)
{
LNN_LOGI(LNN_BUILDER, "LnnInitCloudSyncModule enter.");
LNN_LOGI(LNN_BUILDER, "enter.");
int32_t dbId = 0;
if (LnnCreateKvAdapter(&dbId, APPID, strlen(APPID), STOREID, strlen(STOREID)) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "Lnn Init Cloud Sync Module fail");
@ -983,7 +989,7 @@ void LnnInitCloudSyncModule(void)
void LnnDeInitCloudSyncModule(void)
{
LNN_LOGI(LNN_BUILDER, "LnnDeInitCloudSyncModule enter.");
LNN_LOGI(LNN_BUILDER, "enter.");
int32_t dbId = g_dbId;
if (LnnDestroyKvAdapter(dbId) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "DeInit Cloud Sync module fail");