From e9560a66780c187711571132650fb7aadfc1cbf2 Mon Sep 17 00:00:00 2001 From: htt1997 Date: Wed, 24 Apr 2024 10:57:07 +0800 Subject: [PATCH 1/7] feature:add waterVersionManger Signed-off-by: htt1997 --- .../app/src/checker/bundle_checker.cpp | 36 ++ .../app/src/checker/bundle_checker.h | 9 + .../app/src/checker/system_checker.cpp | 36 ++ .../app/src/checker/system_checker.h | 9 + .../framework/checker/checker_manager.cpp | 53 +++ .../include/checker/checker_manager.h | 10 + .../framework/include/store/general_store.h | 2 + .../distributeddataservice/service/BUILD.gn | 8 +- .../service/rdb/rdb_general_store.cpp | 5 + .../service/rdb/rdb_general_store.h | 1 + .../service/test/BUILD.gn | 62 +++ .../test/water_version_manager_test.cpp | 419 ++++++++++++++++++ .../waterversion/water_version_manager.cpp | 408 +++++++++++++++++ .../waterversion/water_version_manager.h | 85 ++++ 14 files changed, 1140 insertions(+), 3 deletions(-) create mode 100644 services/distributeddataservice/service/test/water_version_manager_test.cpp create mode 100644 services/distributeddataservice/service/waterversion/water_version_manager.cpp create mode 100644 services/distributeddataservice/service/waterversion/water_version_manager.h diff --git a/services/distributeddataservice/app/src/checker/bundle_checker.cpp b/services/distributeddataservice/app/src/checker/bundle_checker.cpp index 69c2739e3..99cf4e902 100644 --- a/services/distributeddataservice/app/src/checker/bundle_checker.cpp +++ b/services/distributeddataservice/app/src/checker/bundle_checker.cpp @@ -108,5 +108,41 @@ bool BundleChecker::IsDistrust(const CheckerManager::StoreInfo &info) } return false; } +std::vector BundleChecker::GetDynamicStores() +{ + return dynamicStores_; +} +std::vector BundleChecker::GetStaticStores() +{ + return staticStores_; +} +bool BundleChecker::IsDynamicStores(const CheckerManager::StoreInfo &info) +{ + for (const auto &store : dynamicStores_) { + if (info.bundleName == store.bundleName && info.storeId == store.storeId) { + return true; + } + } + return false; +} +bool BundleChecker::IsStaticStores(const CheckerManager::StoreInfo &info) +{ + for (const auto &store : staticStores_) { + if (info.bundleName == store.bundleName && info.storeId == store.storeId) { + return true; + } + } + return false; +} +bool BundleChecker::SetDynamicStores(const std::vector &storeInfos) +{ + dynamicStores_ = storeInfos; + return true; +} +bool BundleChecker::SetStaticStores(const std::vector &storeInfos) +{ + staticStores_ = storeInfos; + return true; +} } // namespace DistributedData } // namespace OHOS \ No newline at end of file diff --git a/services/distributeddataservice/app/src/checker/bundle_checker.h b/services/distributeddataservice/app/src/checker/bundle_checker.h index 539234738..9485cb4e3 100644 --- a/services/distributeddataservice/app/src/checker/bundle_checker.h +++ b/services/distributeddataservice/app/src/checker/bundle_checker.h @@ -28,10 +28,19 @@ public: std::string GetAppId(const CheckerManager::StoreInfo &info) override; bool IsValid(const CheckerManager::StoreInfo &info) override; bool IsDistrust(const CheckerManager::StoreInfo &info) override; + bool SetDynamicStores(const std::vector &storeInfos) override; + bool SetStaticStores(const std::vector &storeInfos) override; + std::vector GetDynamicStores() override; + std::vector GetStaticStores() override; + bool IsDynamicStores(const CheckerManager::StoreInfo &info) override; + bool IsStaticStores(const CheckerManager::StoreInfo &info) override; + private: static BundleChecker instance_; std::map trusts_; std::map distrusts_; + std::vector dynamicStores_; + std::vector staticStores_; }; } // namespace DistributedData } // namespace OHOS diff --git a/services/distributeddataservice/app/src/checker/system_checker.cpp b/services/distributeddataservice/app/src/checker/system_checker.cpp index aff8299e0..e219aebda 100644 --- a/services/distributeddataservice/app/src/checker/system_checker.cpp +++ b/services/distributeddataservice/app/src/checker/system_checker.cpp @@ -73,5 +73,41 @@ bool SystemChecker::IsDistrust(const CheckerManager::StoreInfo &info) } return false; } +std::vector SystemChecker::GetDynamicStores() +{ + return dynamicStores_; +} +std::vector SystemChecker::GetStaticStores() +{ + return staticStores_; +} +bool SystemChecker::IsDynamicStores(const CheckerManager::StoreInfo &info) +{ + for (const auto &store : dynamicStores_) { + if (info.bundleName == store.bundleName && info.storeId == store.storeId) { + return true; + } + } + return false; +} +bool SystemChecker::IsStaticStores(const CheckerManager::StoreInfo &info) +{ + for (const auto &store : staticStores_) { + if (info.bundleName == store.bundleName && info.storeId == store.storeId) { + return true; + } + } + return false; +} +bool SystemChecker::SetDynamicStores(const std::vector &storeInfos) +{ + dynamicStores_ = storeInfos; + return true; +} +bool SystemChecker::SetStaticStores(const std::vector &storeInfos) +{ + staticStores_ = storeInfos; + return true; +} } // namespace DistributedData } // namespace OHOS \ No newline at end of file diff --git a/services/distributeddataservice/app/src/checker/system_checker.h b/services/distributeddataservice/app/src/checker/system_checker.h index f81bcc995..84c3fe655 100644 --- a/services/distributeddataservice/app/src/checker/system_checker.h +++ b/services/distributeddataservice/app/src/checker/system_checker.h @@ -29,10 +29,19 @@ public: std::string GetAppId(const CheckerManager::StoreInfo &info) override; bool IsValid(const CheckerManager::StoreInfo &info) override; bool IsDistrust(const CheckerManager::StoreInfo &info) override; + bool SetDynamicStores(const std::vector &storeInfos) override; + bool SetStaticStores(const std::vector &storeInfos) override; + std::vector GetDynamicStores() override; + std::vector GetStaticStores() override; + bool IsDynamicStores(const CheckerManager::StoreInfo &info) override; + bool IsStaticStores(const CheckerManager::StoreInfo &info) override; + private: std::map trusts_; std::map distrusts_; static SystemChecker instance_; + std::vector dynamicStores_; + std::vector staticStores_; }; } // namespace DistributedData } // namespace OHOS diff --git a/services/distributeddataservice/framework/checker/checker_manager.cpp b/services/distributeddataservice/framework/checker/checker_manager.cpp index 9a384153d..8d2099b1e 100644 --- a/services/distributeddataservice/framework/checker/checker_manager.cpp +++ b/services/distributeddataservice/framework/checker/checker_manager.cpp @@ -98,5 +98,58 @@ CheckerManager::Checker *CheckerManager::GetChecker(const std::string &checker) } return it->second; } + +std::vector CheckerManager::GetDynamicStores() +{ + std::vector res; + for (auto &[name, checker] : checkers_) { + if (checker == nullptr) { + continue; + } + res = checker->GetDynamicStores(); + if (!res.empty()) { + return res; + } + } + return res; +} +std::vector CheckerManager::GetStaticStores() +{ + std::vector res; + for (auto &[name, checker] : checkers_) { + if (checker == nullptr) { + continue; + } + res = checker->GetStaticStores(); + if (!res.empty()) { + return res; + } + } + return res; +} +bool CheckerManager::IsDynamicStores(const CheckerManager::StoreInfo &info) +{ + for (auto &[name, checker] : checkers_) { + if (checker == nullptr) { + continue; + } + if (checker->IsDynamicStores(info)) { + return true; + } + } + return false; +} +bool CheckerManager::IsStaticStores(const CheckerManager::StoreInfo &info) +{ + for (auto &[name, checker] : checkers_) { + if (checker == nullptr) { + continue; + } + if (checker->IsStaticStores(info)) { + return true; + } + } + return false; +} } // namespace DistributedData } // namespace OHOS \ No newline at end of file diff --git a/services/distributeddataservice/framework/include/checker/checker_manager.h b/services/distributeddataservice/framework/include/checker/checker_manager.h index b54063d7e..58628ecd8 100644 --- a/services/distributeddataservice/framework/include/checker/checker_manager.h +++ b/services/distributeddataservice/framework/include/checker/checker_manager.h @@ -44,12 +44,22 @@ public: virtual std::string GetAppId(const StoreInfo &info) = 0; virtual bool IsValid(const StoreInfo &info) = 0; virtual bool IsDistrust(const StoreInfo &info) = 0; + virtual bool SetDynamicStores(const std::vector& storeInfos) = 0; + virtual bool SetStaticStores(const std::vector& storeInfos) = 0; + virtual std::vector GetDynamicStores() = 0; + virtual std::vector GetStaticStores() = 0; + virtual bool IsDynamicStores(const StoreInfo &info) = 0; + virtual bool IsStaticStores(const StoreInfo &info) = 0; protected: API_EXPORT ~Checker() = default; }; API_EXPORT static CheckerManager &GetInstance(); API_EXPORT void RegisterPlugin(const std::string &checker, std::function getter); API_EXPORT std::string GetAppId(const StoreInfo &info); + API_EXPORT std::vector GetDynamicStores(); + API_EXPORT std::vector GetStaticStores(); + API_EXPORT bool IsDynamicStores(const StoreInfo &info); + API_EXPORT bool IsStaticStores(const StoreInfo &info); API_EXPORT bool IsValid(const StoreInfo &info); API_EXPORT bool IsDistrust(const StoreInfo &info); API_EXPORT void LoadCheckers(std::vector &checkers); diff --git a/services/distributeddataservice/framework/include/store/general_store.h b/services/distributeddataservice/framework/include/store/general_store.h index f2a4b2c1e..aaad95a54 100644 --- a/services/distributeddataservice/framework/include/store/general_store.h +++ b/services/distributeddataservice/framework/include/store/general_store.h @@ -130,6 +130,8 @@ public: virtual int32_t BindSnapshots(std::shared_ptr>> bindAssets) = 0; virtual int32_t MergeMigratedData(const std::string &tableName, VBuckets&& values) = 0; + + virtual std::string GetWaterVersion(const std::string &deviceId) = 0; }; } // namespace OHOS::DistributedData #endif // OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_STORE_GENERAL_STORE_H diff --git a/services/distributeddataservice/service/BUILD.gn b/services/distributeddataservice/service/BUILD.gn index 98d29c081..80a3fac90 100644 --- a/services/distributeddataservice/service/BUILD.gn +++ b/services/distributeddataservice/service/BUILD.gn @@ -36,10 +36,11 @@ config("module_public_config") { "object", "permission/include", "rdb", + "waterversion", "//third_party/json/single_include", - "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/adapter/include", - "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/app/src", - "//foundation/distributeddatamgr/datamgr_service/services/distributeddataservice/framework/include", + "${data_service_path}/adapter/include", + "${data_service_path}/app/src", + "${data_service_path}/framework/include", "${datashare_path}/frameworks/native/common/include", "${datashare_path}/interfaces/inner_api/common/include", "${datashare_path}/interfaces/inner_api/consumer/include", @@ -124,6 +125,7 @@ ohos_shared_library("distributeddatasvc") { "rdb/rdb_service_impl.cpp", "rdb/rdb_service_stub.cpp", "rdb/rdb_watcher.cpp", + "waterversion/water_version_manager.cpp", ] cflags = [ "-Wno-multichar", diff --git a/services/distributeddataservice/service/rdb/rdb_general_store.cpp b/services/distributeddataservice/service/rdb/rdb_general_store.cpp index 69d9a8a67..f777d009f 100644 --- a/services/distributeddataservice/service/rdb/rdb_general_store.cpp +++ b/services/distributeddataservice/service/rdb/rdb_general_store.cpp @@ -803,6 +803,11 @@ VBuckets RdbGeneralStore::QuerySql(const std::string& sql, Values &&args) return ValueProxy::Convert(std::move(changedData)); } +std::string RdbGeneralStore::GetWaterVersion(const std::string &deviceId) +{ + return ""; +} + void RdbGeneralStore::ObserverProxy::OnChange(const DBChangedIF &data) { if (!HasWatcher()) { diff --git a/services/distributeddataservice/service/rdb/rdb_general_store.h b/services/distributeddataservice/service/rdb/rdb_general_store.h index ce894521d..fc6d4a7ba 100644 --- a/services/distributeddataservice/service/rdb/rdb_general_store.h +++ b/services/distributeddataservice/service/rdb/rdb_general_store.h @@ -75,6 +75,7 @@ public: int32_t Release() override; int32_t BindSnapshots(std::shared_ptr>> bindAssets) override; int32_t MergeMigratedData(const std::string &tableName, VBuckets&& values) override; + std::string GetWaterVersion(const std::string &deviceId) override; private: RdbGeneralStore(const RdbGeneralStore& rdbGeneralStore); diff --git a/services/distributeddataservice/service/test/BUILD.gn b/services/distributeddataservice/service/test/BUILD.gn index 87f0d1504..727322e4f 100644 --- a/services/distributeddataservice/service/test/BUILD.gn +++ b/services/distributeddataservice/service/test/BUILD.gn @@ -421,6 +421,67 @@ ohos_unittest("UdmfRunTimeStoreTest") { ] } +ohos_unittest("WaterVersionManagerTest") { + module_out_path = module_output_path + sources = [ + "${data_service_path}/service/backup/src/backup_manager.cpp", + "${data_service_path}/service/bootstrap/src/bootstrap.cpp", + "${data_service_path}/service/config/src/config_factory.cpp", + "${data_service_path}/service/config/src/model/backup_config.cpp", + "${data_service_path}/service/config/src/model/checker_config.cpp", + "${data_service_path}/service/config/src/model/component_config.cpp", + "${data_service_path}/service/config/src/model/directory_config.cpp", + "${data_service_path}/service/config/src/model/global_config.cpp", + "${data_service_path}/service/config/src/model/network_config.cpp", + "${data_service_path}/service/config/src/model/protocol_config.cpp", + "${data_service_path}/service/waterversion/water_version_manager.cpp", + "mock/db_change_data_mock.cpp", + "mock/db_store_mock.cpp", + "water_version_manager_test.cpp" + ] + + include_dirs = [ + "${data_service_path}/service/backup/include", + "${data_service_path}/service/bootstrap/include", + "${data_service_path}/service/cloud", + "${data_service_path}/service/common", + "${data_service_path}/service/config/include", + "${data_service_path}/service/crypto/include", + "${data_service_path}/service/dumper/include", + "${data_service_path}/service/kvdb", + "${data_service_path}/service/matrix/include", + "${data_service_path}/service/object", + "${data_service_path}/service/permission/include", + "${data_service_path}/service/rdb", + "${data_service_path}/service/waterversion", + "${data_service_path}/adapter/include", + "${data_service_path}/app/src", + "${data_service_path}/framework/include" + ] + + configs = [ ":module_private_config" ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libtokenid_sdk", + "c_utils:utils", + "device_auth:deviceauth_sdk", + "device_manager:devicemanagersdk", + "dfs_service:cloudsync_asset_kit_inner", + "hilog:libhilog", + "huks:libhukssdk", + "ipc:ipc_core", + ] + + deps = [ + "${data_service_path}/adapter:distributeddata_adapter", + "${data_service_path}/framework:distributeddatasvcfwk", + "${data_service_path}/service:distributeddatasvc", + "${kv_store_distributeddb_path}:distributeddb", + "//third_party/googletest:gtest_main", + "//third_party/openssl:libcrypto_shared", + ] +} ############################################################################### group("unittest") { testonly = true @@ -442,6 +503,7 @@ group("unittest") { ":RdbResultSetImplTest", ":UdmfRunTimeStoreTest", ":ValueProxyTest", + ":WaterVersionManagerTest", ] } ############################################################################### diff --git a/services/distributeddataservice/service/test/water_version_manager_test.cpp b/services/distributeddataservice/service/test/water_version_manager_test.cpp new file mode 100644 index 000000000..5f63fffc9 --- /dev/null +++ b/services/distributeddataservice/service/test/water_version_manager_test.cpp @@ -0,0 +1,419 @@ +/* + * 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 "water_version_manager.h" + +#include "checker/checker_manager.h" +#include "block_data.h" +#include "device_manager_adapter.h" +#include "bootstrap.h" +#include "gtest/gtest.h" +#include "ipc_skeleton.h" +#include "metadata/meta_data_manager.h" +#include "mock/db_store_mock.h" +#include "serializable/serializable.h" +#include "utils/constant.h" +using namespace testing::ext; +using namespace OHOS::DistributedData; +using DMAdapter = DeviceManagerAdapter; +using namespace DistributedDB; +using WaterVersionMetaData = WaterVersionManager::WaterVersionMetaData; + +namespace OHOS::Test { +namespace DistributedDataTest { +class TestChecker; +class WaterVersionManagerTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + +protected: + static constexpr const char *TEST_DEVICE = "14a0a92a428005db27c40bad46bf145fede38ec37effe0347cd990fcb031f320"; + void InitMetaData(); + + static std::shared_ptr dbStoreMock_; + static WaterVersionMetaData meta_; + static std::vector> stores_; +}; +class TestChecker : public CheckerManager::Checker { +public: + TestChecker() noexcept + { + CheckerManager::GetInstance().RegisterPlugin( + "SystemChecker", [this]() -> auto { return this; }); + } + ~TestChecker() {} + void Initialize() override {} + bool SetTrustInfo(const CheckerManager::Trust &trust) override + { + return true; + } + std::string GetAppId(const CheckerManager::StoreInfo &info) override + { + return info.bundleName; + } + bool IsValid(const CheckerManager::StoreInfo &info) override + { + return true; + } + bool SetDistrustInfo(const CheckerManager::Distrust &distrust) override + { + return true; + }; + + bool IsDistrust(const CheckerManager::StoreInfo &info) override + { + return true; + } + bool SetDynamicStores(const vector &storeInfos) override + { + return false; + } + bool SetStaticStores(const vector &storeInfos) override + { + return false; + } + vector GetDynamicStores() override + { + return {}; + } + vector GetStaticStores() override + { + return { { 0, 0, "bundle0", "store0" }, { 0, 0, "bundle1", "store0" }, { 0, 0, "bundle2", "store0" } }; + } + bool IsDynamicStores(const CheckerManager::StoreInfo &info) override + { + return false; + } + bool IsStaticStores(const CheckerManager::StoreInfo &info) override + { + return false; + } +}; +TestChecker instance_; +std::shared_ptr WaterVersionManagerTest::dbStoreMock_ = std::make_shared(); +WaterVersionMetaData WaterVersionManagerTest::meta_; +std::vector> WaterVersionManagerTest::stores_ = { { "bundle0", "store0" }, + { "bundle1", "store0" }, { "bundle2", "store0" } }; +void WaterVersionManagerTest::SetUpTestCase(void) +{ + Bootstrap::GetInstance().LoadCheckers(); + MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr); + + meta_.deviceId = TEST_DEVICE; + meta_.version = WaterVersionManager::WaterVersionMetaData::DEFAULT_VERSION; + meta_.waterVersion = 0; + meta_.type = WaterVersionManager::STATIC; + meta_.keys.clear(); + for (auto &it : stores_) { + meta_.keys.push_back(Constant::Join(it.first, Constant::KEY_SEPARATOR, { it.second })); + } + meta_.infos = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } }; +} + +void WaterVersionManagerTest::TearDownTestCase(void) {} + +void WaterVersionManagerTest::SetUp() +{ + InitMetaData(); +} + +void WaterVersionManagerTest::TearDown() +{ + WaterVersionManager::GetInstance().DelWaterVersion(TEST_DEVICE); + WaterVersionManager::GetInstance().DelWaterVersion(DMAdapter::GetInstance().GetLocalDevice().uuid); + MetaDataManager::GetInstance().DelMeta(meta_.GetKey(), true); +} + +void WaterVersionManagerTest::InitMetaData() +{ + MetaDataManager::GetInstance().SaveMeta(meta_.GetKey(), meta_, true); +} + +/** +* @tc.name: SetWaterVersionTest1 +* @tc.desc: updating remote device water version once; +* @tc.type: FUNC +* @tc.require: +* @tc.author: ht +*/ +HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest1, TestSize.Level0) +{ + std::string waterVersion; + ASSERT_TRUE( + WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, waterVersion)); + ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); + WaterVersionManager::WaterVersionMetaData meta; + ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); + meta.infos[0] = { 1, 0, 0 }; + meta.waterVersion = 1; + + EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, + Serializable::Marshall(meta))) + << Serializable::Marshall(meta); + ASSERT_TRUE( + WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, waterVersion)); + ASSERT_EQ(Serializable::Marshall(meta), waterVersion); + + ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); + EXPECT_EQ(meta.GetVersion(), 1) << "meta: " << meta.ToAnonymousString(); +} + +/** +* @tc.name: SetWaterVersionTest2 +* @tc.desc: Continuously updating remote device water version more than once; +* @tc.type: FUNC +* @tc.require: +* @tc.author: ht +*/ +HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest2, TestSize.Level0) +{ + std::string waterVersion; + ASSERT_TRUE( + WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, waterVersion)); + ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); + WaterVersionManager::WaterVersionMetaData meta; + ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); + // first store update + meta.infos[0] = { 1, 0, 0 }; + meta.waterVersion = 1; + EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, + Serializable::Marshall(meta))); + uint64_t version; + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_EQ(version, 1); + + // second store update + meta.infos[1] = { 1, 2, 0 }; + meta.waterVersion = 2; + EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, + Serializable::Marshall(meta))); + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_EQ(version, 2); +} + +/** +* @tc.name: SetWaterVersionTest3 +* @tc.desc: A updates first, but B synchronizes first +* @tc.type: FUNC +* @tc.require: +* @tc.author: ht +*/ +HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest3, TestSize.Level0) +{ + std::string waterVersion; + ASSERT_TRUE( + WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, waterVersion)); + ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); + WaterVersionManager::WaterVersionMetaData meta; + ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); + EXPECT_EQ(meta.GetVersion(), 0) << "meta: " << Serializable::Marshall(meta); + + //bundle2 updated later, but sync first. Do not update waterVersion + meta.infos[1] = { 1, 2, 0 }; + meta.waterVersion = 2; + EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, + Serializable::Marshall(meta))); + uint64_t version; + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_EQ(version, 0); + + //bundle1 updated earlier, but sync later. update waterVersion + meta.infos[0] = { 1, 0, 0 }; + meta.waterVersion = 1; + EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, + Serializable::Marshall(meta))); + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_EQ(version, 2); +} + +/** +* @tc.name: SetWaterVersionTest4 +* @tc.desc: updates twice, but sync once +* @tc.type: FUNC +* @tc.require: +* @tc.author: ht +*/ +HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest4, TestSize.Level0) +{ + std::string waterVersion; + ASSERT_TRUE( + WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, waterVersion)); + ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); + WaterVersionManager::WaterVersionMetaData meta; + ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); + EXPECT_EQ(meta.GetVersion(), 0) << "meta: " << Serializable::Marshall(meta); + + //bundle1 updated twice, but sync once. update waterVersion + meta.infos[0] = { 2, 0, 0 }; + meta.waterVersion = 2; + EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, + Serializable::Marshall(meta))); + uint64_t version; + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_EQ(version, 2); +} + +/** +* @tc.name: SetWaterVersionTest5 +* @tc.desc: Update(upload) multiple times, sync(download) fewer times +* @tc.type: FUNC +* @tc.require: +* @tc.author: ht +*/ +HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest5, TestSize.Level0) +{ + std::string waterVersion; + ASSERT_TRUE( + WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, waterVersion)); + ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); + WaterVersionManager::WaterVersionMetaData meta; + ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); + EXPECT_EQ(meta.GetVersion(), 0) << "meta: " << Serializable::Marshall(meta); + + //order: 0(u)->1(u)->0(u)->2(u)->1(s)->2(s)->1(u)->1(u)->0(s) + //1 sync + meta.infos[0] = { 1, 0, 0 }; + meta.infos[1] = { 1, 2, 0 }; + meta.infos[2] = { 0, 0, 0 }; + meta.waterVersion = 2; + EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, + Serializable::Marshall(meta))); + uint64_t version; + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_EQ(version, 0); + + //2 sync + meta.infos[0] = { 3, 2, 0 }; + meta.infos[1] = { 1, 2, 0 }; + meta.infos[2] = { 3, 2, 4 }; + meta.waterVersion = 4; + EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[2].first, stores_[2].second, + Serializable::Marshall(meta))); + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_EQ(version, 0); + + //0 sync + meta.infos[0] = { 3, 2, 0 }; + meta.infos[1] = { 1, 2, 0 }; + meta.infos[2] = { 0, 0, 0 }; + meta.waterVersion = 3; + EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, + Serializable::Marshall(meta))); + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_EQ(version, 4); + std::cout<(5, 5); + for (int i = 0; i < 10; ++i) { + executorPool->Execute([] { + WaterVersionManager::GetInstance().GenerateWaterVersion(stores_[0].first, stores_[0].second); + }); + } + std::this_thread::sleep_for(std::chrono::milliseconds(1000)); + + uint64_t version; + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(DMAdapter::GetInstance().GetLocalDevice().uuid, + WaterVersionManager::STATIC, version)); + EXPECT_EQ(version, 10); +} + +/** +* @tc.name: MixCallTest1 +* @tc.desc: use GenerateWaterVersion to SetWaterVersion +* @tc.type: FUNC +* @tc.require: +* @tc.author: ht +*/ +HWTEST_F(WaterVersionManagerTest, MixCallTest1, TestSize.Level0) +{ + std::string waterVersion = + WaterVersionManager::GetInstance().GenerateWaterVersion(stores_[0].first, stores_[0].second); + WaterVersionManager::WaterVersionMetaData meta; + ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)) << "waterVersion: " << waterVersion; + EXPECT_EQ(meta.waterVersion, 1) << "waterVersion: " << waterVersion; + + meta.deviceId = TEST_DEVICE; + EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, + Serializable::Marshall(meta))); + + uint64_t version; + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_EQ(version, 1) << "waterVersion: " << waterVersion; +} + + +/** +* @tc.name: MixCallTest2 +* @tc.desc: use GenerateWaterVersion to SetWaterVersion and GenerateWaterVersion more than once +* @tc.type: FUNC +* @tc.require: +* @tc.author: ht +*/ +HWTEST_F(WaterVersionManagerTest, MixCallTest2, TestSize.Level0) +{ + for (int i = 1; i < 11; ++i) { + std::string waterVersion = + WaterVersionManager::GetInstance().GenerateWaterVersion(stores_[i % meta_.keys.size()].first, + stores_[i % meta_.keys.size()].second); + WaterVersionManager::WaterVersionMetaData meta; + ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)) << "waterVersion: " << waterVersion; + EXPECT_EQ(meta.waterVersion, i) << "waterVersion: " << waterVersion; + meta.deviceId = TEST_DEVICE; + EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[i % meta_.keys.size()].first, + stores_[i % meta_.keys.size()].second, Serializable::Marshall(meta))); + + uint64_t version; + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_EQ(version, i) << "waterVersion: " << waterVersion; + } +} +} // namespace DistributedDataTest +} // namespace OHOS::Test \ No newline at end of file diff --git a/services/distributeddataservice/service/waterversion/water_version_manager.cpp b/services/distributeddataservice/service/waterversion/water_version_manager.cpp new file mode 100644 index 000000000..77d99f83d --- /dev/null +++ b/services/distributeddataservice/service/waterversion/water_version_manager.cpp @@ -0,0 +1,408 @@ +/* +* Copyright (c) 2022 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. +*/ +#define LOG_TAG "DeviceMatrix" +#include "water_version_manager.h" + +#include "checker/checker_manager.h" +#include "store/auto_cache.h" +#include "device_manager_adapter.h" +#include "log_print.h" +#include "metadata/meta_data_manager.h" +#include "metadata/store_meta_data.h" +#include "utils/anonymous.h" +#include "utils/constant.h" + +namespace OHOS::DistributedData { +using DMAdapter = DeviceManagerAdapter; + +WaterVersionManager &WaterVersionManager::GetInstance() +{ + static WaterVersionManager waterVersionManager; + return waterVersionManager; +} +WaterVersionManager::WaterVersionManager() +{ + std::vector metas; + auto stores = CheckerManager::GetInstance().GetDynamicStores(); + for (const auto &store : stores) { + dynamicKeys_.push_back(Merge(store.bundleName, store.storeId)); + } + stores = CheckerManager::GetInstance().GetStaticStores(); + for (const auto &store : stores) { + staticKeys_.push_back(Merge(store.bundleName, store.storeId)); + } + MetaDataManager::GetInstance().LoadMeta(WaterVersionMetaData::GetPrefix(), metas, true); + for (auto &meta : metas) { + if (meta.type == DYNAMIC) { + if (dynamicKeys_ != meta.keys || meta.version != WaterVersionMetaData::DEFAULT_VERSION) { + meta = Upgrade(dynamicKeys_, meta); + } + dynamicVersions_.Set(meta.deviceId, meta); + MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true); + } + if (meta.type == STATIC) { + if (staticKeys_ != meta.keys || meta.version != WaterVersionMetaData::DEFAULT_VERSION) { + meta = Upgrade(staticKeys_, meta); + } + staticVersions_.Set(meta.deviceId, meta); + MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true); + } + } +} +std::string WaterVersionManager::GenerateWaterVersion(const std::string &bundleName, const std::string &storeName) +{ + WaterVersionMetaData meta; + std::string key = Merge(bundleName, storeName); + for (size_t i = 0; i < staticKeys_.size(); ++i) { + if (staticKeys_[i] == key) { + meta.type = STATIC; + meta.keys = staticKeys_; + return InnerGenerate(i, staticVersions_, meta) ? Serializable::Marshall(meta) : ""; + } + } + for (size_t i = 0; i < dynamicKeys_.size(); ++i) { + if (dynamicKeys_[i] == key) { + meta.type = DYNAMIC; + meta.keys = dynamicKeys_; + return InnerGenerate(i, dynamicVersions_, meta) ? Serializable::Marshall(meta) : ""; + } + } + ZLOGE("invalid param. bundleName:%{public}s, storeName:%{public}s", bundleName.c_str(), storeName.c_str()); + return ""; +} + +bool WaterVersionManager::GetWaterVersion(const std::string &deviceId, WaterVersionManager::Type type, + std::string &waterVersion) +{ + WaterVersionMetaData meta; + if (InnerGetWaterVersion(deviceId, type, meta)) { + waterVersion = Serializable::Marshall(meta); + return true; + } + return false; +} +bool WaterVersionManager::GetWaterVersion(const std::string &deviceId, WaterVersionManager::Type type, + uint64_t &waterVersion) +{ + WaterVersionMetaData meta; + if (InnerGetWaterVersion(deviceId, type, meta)) { + waterVersion = meta.GetVersion(); + return true; + } + return false; +} + +bool WaterVersionManager::SetWaterVersion(const std::string &bundleName, const std::string &storeName, + const std::string &waterVersion) +{ + WaterVersionMetaData metaData; + if (!Serializable::Unmarshall(waterVersion, metaData) || metaData.deviceId.empty() || !metaData.IsValid() || + metaData.deviceId == DMAdapter::GetInstance().GetLocalDevice().uuid) { + ZLOGE("invalid param. meta:%{public}s, bundleName:%{public}s, storeName:%{public}s", + metaData.ToAnonymousString().c_str(), bundleName.c_str(), Anonymous::Change(storeName).c_str()); + return false; + } + + std::string key = Merge(bundleName, storeName); + for (size_t i = 0; i < staticKeys_.size(); ++i) { + if (metaData.type != STATIC) { + break; + } + if (staticKeys_[i] == key) { + return InnerSetWaterVersion(key, metaData, staticVersions_); + } + } + for (size_t i = 0; i < dynamicKeys_.size(); ++i) { + if (metaData.type != DYNAMIC) { + break; + } + if (dynamicKeys_[i] == key) { + return InnerSetWaterVersion(key, metaData, dynamicVersions_); + } + } + ZLOGE("error key. deviceId:%{public}s, bundleName:%{public}s, storeName:%{public}s", + Anonymous::Change(metaData.deviceId).c_str(), bundleName.c_str(), Anonymous::Change(storeName).c_str()); + return false; +} + +bool WaterVersionManager::DelWaterVersion(const std::string &deviceId) +{ + WaterVersionMetaData meta; + if (dynamicVersions_.Get(deviceId, meta)) { + dynamicVersions_.Delete(deviceId); + MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true); + } + if (staticVersions_.Get(deviceId, meta)) { + staticVersions_.Delete(deviceId); + MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true); + } + return true; +} + +bool WaterVersionManager::InnerGenerate(int index, LRUBucket &bucket, + WaterVersionMetaData &metaData) +{ + metaData.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid; + if (metaData.deviceId.empty()) { + ZLOGE("GetLocalDevice failed!"); + return false; + } + metaData.infos = { metaData.keys.size(), std::vector(metaData.keys.size(), 0) }; + // ensure serial execution + std::lock_guard lock(mutex_); + auto status = bucket.Get(metaData.deviceId, metaData); + if (!status && !MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData, true)) { + ZLOGW("no WaterVersion, start InitMeta"); + InitMeta(metaData); + } + metaData.waterVersion++; + // It has been initialized above, so there is no need to check for out of bounds + metaData.infos[index][index] = metaData.waterVersion; + for (size_t i = 0; i < metaData.keys.size(); ++i) { + metaData.infos[index][i] = metaData.infos[i][i]; + } + MetaDataManager::GetInstance().SaveMeta(metaData.GetKey(), metaData, true); + ZLOGI("generate meta:%{public}s", metaData.ToAnonymousString().c_str()); + return bucket.Set(DMAdapter::GetInstance().GetLocalDevice().uuid, metaData); +} + +bool WaterVersionManager::InnerGetWaterVersion(const std::string &deviceId, WaterVersionManager::Type type, + WaterVersionManager::WaterVersionMetaData &meta) +{ + if (deviceId.empty() || type < 0 || type > DYNAMIC) { + ZLOGE("invalid param. deviceId:%{public}s, type:%{public}d", Anonymous::Change(deviceId).c_str(), type); + return false; + } + meta.type = type; + meta.deviceId = deviceId; + bool flag = false; + switch (type) { + case DYNAMIC: + flag = dynamicVersions_.Get(deviceId, meta); + break; + case STATIC: + flag = staticVersions_.Get(deviceId, meta); + break; + default: + ZLOGE("error type:%{public}d. deviceId:%{public}s", type, Anonymous::Change(deviceId).c_str()); + return false; + } + if (!flag && MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + type == DYNAMIC ? dynamicVersions_.Set(deviceId, meta) : staticVersions_.Set(deviceId, meta); + } + ZLOGI("get meta:%{public}s, flag:%{public}d", meta.ToAnonymousString().c_str(), flag); + return true; +} + +bool WaterVersionManager::InnerSetWaterVersion(const std::string &key, + const WaterVersionMetaData &metaData, LRUBucket &bucket) +{ + WaterVersionMetaData oldMeta; + std::lock_guard lock(mutex_); + bool success = bucket.Get(metaData.deviceId, oldMeta); + if (!success && !MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), oldMeta, true)) { + ZLOGI("save meta:%{public}s", metaData.ToAnonymousString().c_str()); + return MetaDataManager::GetInstance().SaveMeta(oldMeta.GetKey(), metaData, true) && + bucket.Set(metaData.deviceId, metaData); + } + if (oldMeta.keys.size() != metaData.keys.size() || oldMeta.version != metaData.version) { + ZLOGI("upgrade meta. old:%{public}s, new:%{public}s", oldMeta.ToAnonymousString().c_str(), + metaData.ToAnonymousString().c_str()); + oldMeta = metaData; + for (size_t i = 0; i < metaData.keys.size(); ++i) { + // Set all unSync items to 0 + if (metaData.keys[i] != key) { + oldMeta.infos[i] = std::vector(metaData.keys.size(), 0); + } + } + } else { + for (size_t i = 0; i < oldMeta.keys.size(); ++i) { + if (oldMeta.keys[i] == key) { + oldMeta.infos[i] = metaData.infos[i]; + break; + } + } + } + UpdateWaterVersion(oldMeta); + return MetaDataManager::GetInstance().SaveMeta(oldMeta.GetKey(), oldMeta, true) && + bucket.Set(metaData.deviceId, oldMeta); +} + +bool WaterVersionManager::InitMeta(WaterVersionMetaData &metaData) +{ + metaData.waterVersion = 0; + std::string uuid = DMAdapter::GetInstance().GetLocalDevice().uuid; + for (size_t i = 0; i < metaData.keys.size(); ++i) { + auto key = metaData.keys[i]; + StoreMetaData storeMetaData; + storeMetaData.user = std::to_string(0); + std::tie(storeMetaData.bundleName, storeMetaData.storeId) = Split(key); + storeMetaData.instanceId = 0; + if (!MetaDataManager::GetInstance().LoadMeta(storeMetaData.GetKey(), storeMetaData, true)) { + ZLOGE("no store! bundleName:%{public}s, storeName:%{public}s", storeMetaData.bundleName.c_str(), + storeMetaData.storeId.c_str()); + continue; + } + auto store = AutoCache::GetInstance().GetStore(storeMetaData, {}); + if (store == nullptr) { + ZLOGE("store is null! bundleName:%{public}s, storeName:%{public}s", storeMetaData.bundleName.c_str(), + storeMetaData.storeId.c_str()); + continue; + } + auto waterVersion = store->GetWaterVersion(uuid); + WaterVersionMetaData meta; + if (waterVersion.empty() || !Serializable::Unmarshall(waterVersion, meta)) { + ZLOGE("GetWaterVersion failed! bundleName:%{public}s, storeName:%{public}s, meta:%{public}s", + storeMetaData.bundleName.c_str(), storeMetaData.storeId.c_str(), meta.ToAnonymousString().c_str()); + continue; + } + if (meta.version != metaData.version || meta.keys != metaData.keys) { + meta = Upgrade(metaData.keys, meta); + } + metaData.infos[i] = meta.infos[i]; + } + UpdateWaterVersion(metaData); + return true; +} +void WaterVersionManager::UpdateWaterVersion(WaterVersionManager::WaterVersionMetaData &metaData) const +{ + ZLOGI("before update meta:%{public}s", metaData.ToAnonymousString().c_str()); + for (size_t i = 0; i < metaData.keys.size(); ++i) { + for (size_t j = 0; j < metaData.keys.size(); ++j) { + if (metaData.infos[i][j] > metaData.infos[j][j]) { + break; + } + if (j == metaData.keys.size() - 1 && metaData.infos[i][i] > metaData.waterVersion) { + metaData.waterVersion = metaData.infos[i][i]; + } + } + } + ZLOGI("after update meta:%{public}s", metaData.ToAnonymousString().c_str()); +} + +std::string WaterVersionManager::Merge(const std::string &bundleName, const std::string &storeName) +{ + return Constant::Join(bundleName, Constant::KEY_SEPARATOR, { storeName }); +} + +std::pair WaterVersionManager::Split(const std::string &key) +{ + std::vector res; + size_t pos = 0; + std::string delim(Constant::KEY_SEPARATOR); + while (pos < key.size()) { + size_t found = key.find(delim, pos); + if (found == std::string::npos) { + res.push_back(key.substr(pos)); + break; + } + res.push_back(key.substr(pos, found - pos)); + pos = found + delim.size(); + } + if (res.size() < 2) { + return { "", "" }; + } + return { res[0], res[1] }; +} + +WaterVersionManager::WaterVersionMetaData WaterVersionManager::Upgrade(const std::vector &keys, + const WaterVersionManager::WaterVersionMetaData &meta) +{ + WaterVersionMetaData newMeta; + newMeta.keys = keys; + newMeta.version = WaterVersionMetaData::DEFAULT_VERSION; + newMeta.deviceId = meta.deviceId; + newMeta.waterVersion = meta.waterVersion; + newMeta.type = meta.type; + newMeta.infos = { keys.size(), std::vector(keys.size(), 0) }; + std::map mp; + for (size_t i = 0; i < keys.size(); ++i) { + for (size_t j = 0; j < meta.keys.size(); ++j) { + if (meta.keys[j] == keys[i]) { + mp[j] = i; + } + } + } + for (size_t i = 0; i < meta.keys.size(); ++i) { + if (!mp.count(i)) { + continue; + } + for (size_t j = 0; j < meta.keys.size(); ++j) { + if (!mp.count(j)) { + continue; + } + newMeta.infos[mp[i]][mp[j]] = meta.infos[i][j]; + } + } + return newMeta; +} +bool WaterVersionManager::WaterVersionMetaData::Marshal(Serializable::json &node) const +{ + SetValue(node[GET_NAME(deviceId)], deviceId); + SetValue(node[GET_NAME(version)], version); + SetValue(node[GET_NAME(waterVersion)], waterVersion); + SetValue(node[GET_NAME(type)], type); + SetValue(node[GET_NAME(keys)], keys); + SetValue(node[GET_NAME(infos)], infos); + return true; +} +bool WaterVersionManager::WaterVersionMetaData::Unmarshal(const Serializable::json &node) +{ + GetValue(node, GET_NAME(deviceId), deviceId); + GetValue(node, GET_NAME(version), version); + GetValue(node, GET_NAME(waterVersion), waterVersion); + int32_t tmp = -1; + GetValue(node, GET_NAME(type), tmp); + if (tmp < 0 || tmp > DYNAMIC) { + return false; + } + type = static_cast(tmp); + GetValue(node, GET_NAME(keys), keys); + GetValue(node, GET_NAME(infos), infos); + return true; +} +std::string WaterVersionManager::WaterVersionMetaData::ToAnonymousString() const +{ + json root; + Marshal(root); + SetValue(root[GET_NAME(deviceId)], Anonymous::Change(deviceId)); + return root.dump(-1, ' ', false, error_handler_t::replace); +} +std::string WaterVersionManager::WaterVersionMetaData::GetKey() const +{ + return Constant::Join(KEY_PREFIX, Constant::KEY_SEPARATOR, { deviceId, std::to_string(type) }); +} +uint64_t WaterVersionManager::WaterVersionMetaData::GetVersion() +{ + return waterVersion; +} +std::string WaterVersionManager::WaterVersionMetaData::GetPrefix() +{ + return KEY_PREFIX; +} + +bool WaterVersionManager::WaterVersionMetaData::IsValid() +{ + if (keys.size() != infos.size()) { + return false; + } + for (const auto &info : infos) { + if (info.size() != keys.size()) { + return false; + } + } + return true; +} +} // namespace OHOS::DistributedData diff --git a/services/distributeddataservice/service/waterversion/water_version_manager.h b/services/distributeddataservice/service/waterversion/water_version_manager.h new file mode 100644 index 000000000..c18ddd578 --- /dev/null +++ b/services/distributeddataservice/service/waterversion/water_version_manager.h @@ -0,0 +1,85 @@ +/* +* 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 OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_WATER_MANAGER_H +#define OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_WATER_MANAGER_H +#include +#include +#include +#include "serializable/serializable.h" +#include "lru_bucket.h" + +namespace OHOS { +namespace DistributedData { +class WaterVersionManager { +public: + enum Type { + STATIC, + DYNAMIC + }; + class WaterVersionMetaData final : public Serializable { + public: + static constexpr uint32_t DEFAULT_VERSION = 0; + std::string deviceId; + uint32_t version = DEFAULT_VERSION; + uint64_t waterVersion = 0; + Type type; + std::vector keys; + std::vector> infos; + bool Marshal(json &node) const override; + bool Unmarshal(const json &node) override; + bool IsValid(); + std::string ToAnonymousString() const; + std::string GetKey() const; + uint64_t GetVersion(); + static std::string GetPrefix(); + + private: + static constexpr const char *KEY_PREFIX = "WaterVersionMeta"; + }; + static WaterVersionManager &GetInstance(); + WaterVersionManager(); + // 生成本地水位 + std::string GenerateWaterVersion(const std::string &bundleName, const std::string &storeName); + // 根据deviceId和type获取水位 + bool GetWaterVersion(const std::string &deviceId, Type type, std::string &waterVersion); + // 根据deviceId和type获取水位 + bool GetWaterVersion(const std::string &deviceId, Type type, uint64_t &waterVersion); + // 更新其它设备水位 + bool SetWaterVersion(const std::string &bundleName, const std::string &storeName, + const std::string &waterVersion); + // 删除水位 + bool DelWaterVersion(const std::string &deviceId); + +private: + bool InnerGenerate(int index, LRUBucket &bucket, + WaterVersionMetaData &metaData); + bool InnerGetWaterVersion(const std::string &deviceId, Type type, WaterVersionMetaData &waterVersion); + bool InnerSetWaterVersion(const std::string &key, const WaterVersionMetaData &waterVersionMetaData, + LRUBucket &bucket); + bool InitMeta(WaterVersionMetaData &); + WaterVersionMetaData Upgrade(const std::vector &keys, const WaterVersionMetaData& meta); + std::string Merge(const std::string &bundleName, const std::string &storeName); + std::pair Split(const std::string &key); + static constexpr size_t MAX_DEVICES = 16; + std::mutex mutex_; + std::vector staticKeys_;// = { "bundle0###store0", "bundle1###store0", "bundle2###store0" }; + std::vector dynamicKeys_;// = { "bundle0###store1", "bundle1###store1", "bundle4###store0" }; + LRUBucket staticVersions_{ MAX_DEVICES }; + LRUBucket dynamicVersions_{ MAX_DEVICES }; + void UpdateWaterVersion(WaterVersionMetaData &metaData) const; +}; +} // namespace DistributedData +} // namespace OHOS +#endif //OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_WATER_MANAGER_H -- Gitee From eeb00eb967bd6733672c7b180523267ff9b18cee Mon Sep 17 00:00:00 2001 From: htt1997 Date: Thu, 25 Apr 2024 18:41:03 +0800 Subject: [PATCH 2/7] fix Signed-off-by: htt1997 --- .../app/src/checker/bundle_checker.cpp | 13 +- .../app/src/checker/bundle_checker.h | 8 +- .../app/src/checker/system_checker.cpp | 12 +- .../app/src/checker/system_checker.h | 8 +- .../app/src/kvstore_data_service.cpp | 1 + .../distributeddataservice/framework/BUILD.gn | 1 + .../framework/checker/checker_manager.cpp | 8 +- .../framework/cloud/cloud_config_manager.cpp | 49 +++++++ .../include/checker/checker_manager.h | 12 +- .../include/cloud/cloud_config_manager.h | 43 ++++++ .../distributeddataservice/service/BUILD.gn | 1 + .../service/bootstrap/include/bootstrap.h | 1 + .../service/bootstrap/src/bootstrap.cpp | 28 ++++ .../service/config/include/config_factory.h | 1 + .../config/include/model/checker_config.h | 8 ++ .../config/include/model/cloud_config.h | 35 +++++ .../config/include/model/global_config.h | 2 + .../service/config/src/config_factory.cpp | 5 + .../config/src/model/checker_config.cpp | 19 +++ .../service/config/src/model/cloud_config.cpp | 43 ++++++ .../config/src/model/global_config.cpp | 3 + .../service/test/BUILD.gn | 17 ++- .../fuzztest/cloudservicestub_fuzzer/BUILD.gn | 1 + .../fuzztest/kvdbservicestub_fuzzer/BUILD.gn | 1 + .../objectservicestub_fuzzer/BUILD.gn | 1 + .../fuzztest/rdbservicestub_fuzzer/BUILD.gn | 1 + .../test/water_version_manager_test.cpp | 128 ++++++++++++------ .../waterversion/water_version_manager.cpp | 7 +- .../waterversion/water_version_manager.h | 4 +- 29 files changed, 385 insertions(+), 76 deletions(-) create mode 100644 services/distributeddataservice/framework/cloud/cloud_config_manager.cpp create mode 100644 services/distributeddataservice/framework/include/cloud/cloud_config_manager.h create mode 100644 services/distributeddataservice/service/config/include/model/cloud_config.h create mode 100644 services/distributeddataservice/service/config/src/model/cloud_config.cpp diff --git a/services/distributeddataservice/app/src/checker/bundle_checker.cpp b/services/distributeddataservice/app/src/checker/bundle_checker.cpp index 99cf4e902..46120ac37 100644 --- a/services/distributeddataservice/app/src/checker/bundle_checker.cpp +++ b/services/distributeddataservice/app/src/checker/bundle_checker.cpp @@ -116,7 +116,7 @@ std::vector BundleChecker::GetStaticStores() { return staticStores_; } -bool BundleChecker::IsDynamicStores(const CheckerManager::StoreInfo &info) +bool BundleChecker::IsDynamic(const CheckerManager::StoreInfo &info) { for (const auto &store : dynamicStores_) { if (info.bundleName == store.bundleName && info.storeId == store.storeId) { @@ -125,7 +125,7 @@ bool BundleChecker::IsDynamicStores(const CheckerManager::StoreInfo &info) } return false; } -bool BundleChecker::IsStaticStores(const CheckerManager::StoreInfo &info) +bool BundleChecker::IsStatic(const CheckerManager::StoreInfo &info) { for (const auto &store : staticStores_) { if (info.bundleName == store.bundleName && info.storeId == store.storeId) { @@ -134,14 +134,15 @@ bool BundleChecker::IsStaticStores(const CheckerManager::StoreInfo &info) } return false; } -bool BundleChecker::SetDynamicStores(const std::vector &storeInfos) + +bool BundleChecker::AddDynamicStore(const CheckerManager::StoreInfo &storeInfo) { - dynamicStores_ = storeInfos; + dynamicStores_.push_back(storeInfo); return true; } -bool BundleChecker::SetStaticStores(const std::vector &storeInfos) +bool BundleChecker::AddStaticStore(const CheckerManager::StoreInfo &storeInfo) { - staticStores_ = storeInfos; + staticStores_.push_back(storeInfo); return true; } } // namespace DistributedData diff --git a/services/distributeddataservice/app/src/checker/bundle_checker.h b/services/distributeddataservice/app/src/checker/bundle_checker.h index 9485cb4e3..b3c2362f3 100644 --- a/services/distributeddataservice/app/src/checker/bundle_checker.h +++ b/services/distributeddataservice/app/src/checker/bundle_checker.h @@ -28,12 +28,12 @@ public: std::string GetAppId(const CheckerManager::StoreInfo &info) override; bool IsValid(const CheckerManager::StoreInfo &info) override; bool IsDistrust(const CheckerManager::StoreInfo &info) override; - bool SetDynamicStores(const std::vector &storeInfos) override; - bool SetStaticStores(const std::vector &storeInfos) override; + bool AddDynamicStore(const CheckerManager::StoreInfo& storeInfo) override; + bool AddStaticStore(const CheckerManager::StoreInfo& storeInfo) override; std::vector GetDynamicStores() override; std::vector GetStaticStores() override; - bool IsDynamicStores(const CheckerManager::StoreInfo &info) override; - bool IsStaticStores(const CheckerManager::StoreInfo &info) override; + bool IsDynamic(const CheckerManager::StoreInfo &info) override; + bool IsStatic(const CheckerManager::StoreInfo &info) override; private: static BundleChecker instance_; diff --git a/services/distributeddataservice/app/src/checker/system_checker.cpp b/services/distributeddataservice/app/src/checker/system_checker.cpp index e219aebda..caf23ebde 100644 --- a/services/distributeddataservice/app/src/checker/system_checker.cpp +++ b/services/distributeddataservice/app/src/checker/system_checker.cpp @@ -81,7 +81,7 @@ std::vector SystemChecker::GetStaticStores() { return staticStores_; } -bool SystemChecker::IsDynamicStores(const CheckerManager::StoreInfo &info) +bool SystemChecker::IsDynamic(const CheckerManager::StoreInfo &info) { for (const auto &store : dynamicStores_) { if (info.bundleName == store.bundleName && info.storeId == store.storeId) { @@ -90,7 +90,7 @@ bool SystemChecker::IsDynamicStores(const CheckerManager::StoreInfo &info) } return false; } -bool SystemChecker::IsStaticStores(const CheckerManager::StoreInfo &info) +bool SystemChecker::IsStatic(const CheckerManager::StoreInfo &info) { for (const auto &store : staticStores_) { if (info.bundleName == store.bundleName && info.storeId == store.storeId) { @@ -99,14 +99,14 @@ bool SystemChecker::IsStaticStores(const CheckerManager::StoreInfo &info) } return false; } -bool SystemChecker::SetDynamicStores(const std::vector &storeInfos) +bool SystemChecker::AddDynamicStore(const CheckerManager::StoreInfo &storeInfo) { - dynamicStores_ = storeInfos; + dynamicStores_.push_back(storeInfo); return true; } -bool SystemChecker::SetStaticStores(const std::vector &storeInfos) +bool SystemChecker::AddStaticStore(const CheckerManager::StoreInfo &storeInfo) { - staticStores_ = storeInfos; + staticStores_.push_back(storeInfo); return true; } } // namespace DistributedData diff --git a/services/distributeddataservice/app/src/checker/system_checker.h b/services/distributeddataservice/app/src/checker/system_checker.h index 84c3fe655..8e8fa4f7c 100644 --- a/services/distributeddataservice/app/src/checker/system_checker.h +++ b/services/distributeddataservice/app/src/checker/system_checker.h @@ -29,12 +29,12 @@ public: std::string GetAppId(const CheckerManager::StoreInfo &info) override; bool IsValid(const CheckerManager::StoreInfo &info) override; bool IsDistrust(const CheckerManager::StoreInfo &info) override; - bool SetDynamicStores(const std::vector &storeInfos) override; - bool SetStaticStores(const std::vector &storeInfos) override; + bool AddDynamicStore(const CheckerManager::StoreInfo &storeInfos) override; + bool AddStaticStore(const CheckerManager::StoreInfo &storeInfos) override; std::vector GetDynamicStores() override; std::vector GetStaticStores() override; - bool IsDynamicStores(const CheckerManager::StoreInfo &info) override; - bool IsStaticStores(const CheckerManager::StoreInfo &info) override; + bool IsDynamic(const CheckerManager::StoreInfo &info) override; + bool IsStatic(const CheckerManager::StoreInfo &info) override; private: std::map trusts_; diff --git a/services/distributeddataservice/app/src/kvstore_data_service.cpp b/services/distributeddataservice/app/src/kvstore_data_service.cpp index 5f02dd481..92d5d13e5 100644 --- a/services/distributeddataservice/app/src/kvstore_data_service.cpp +++ b/services/distributeddataservice/app/src/kvstore_data_service.cpp @@ -280,6 +280,7 @@ void KvStoreDataService::OnStart() Bootstrap::GetInstance().LoadCheckers(); Bootstrap::GetInstance().LoadNetworks(); Bootstrap::GetInstance().LoadBackup(executors_); + Bootstrap::GetInstance().LoadCloud(); Initialize(); auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); if (samgr != nullptr) { diff --git a/services/distributeddataservice/framework/BUILD.gn b/services/distributeddataservice/framework/BUILD.gn index a589f6c6a..6d27470fc 100644 --- a/services/distributeddataservice/framework/BUILD.gn +++ b/services/distributeddataservice/framework/BUILD.gn @@ -51,6 +51,7 @@ ohos_shared_library("distributeddatasvcfwk") { "backuprule/backup_rule_manager.cpp", "checker/checker_manager.cpp", "cloud/asset_loader.cpp", + "cloud/cloud_config_manager.cpp", "cloud/cloud_db.cpp", "cloud/cloud_event.cpp", "cloud/cloud_extra_data.cpp", diff --git a/services/distributeddataservice/framework/checker/checker_manager.cpp b/services/distributeddataservice/framework/checker/checker_manager.cpp index 8d2099b1e..900cfe0da 100644 --- a/services/distributeddataservice/framework/checker/checker_manager.cpp +++ b/services/distributeddataservice/framework/checker/checker_manager.cpp @@ -127,25 +127,25 @@ std::vector CheckerManager::GetStaticStores() } return res; } -bool CheckerManager::IsDynamicStores(const CheckerManager::StoreInfo &info) +bool CheckerManager::IsDynamic(const CheckerManager::StoreInfo &info) { for (auto &[name, checker] : checkers_) { if (checker == nullptr) { continue; } - if (checker->IsDynamicStores(info)) { + if (checker->IsDynamic(info)) { return true; } } return false; } -bool CheckerManager::IsStaticStores(const CheckerManager::StoreInfo &info) +bool CheckerManager::IsStatic(const CheckerManager::StoreInfo &info) { for (auto &[name, checker] : checkers_) { if (checker == nullptr) { continue; } - if (checker->IsStaticStores(info)) { + if (checker->IsStatic(info)) { return true; } } diff --git a/services/distributeddataservice/framework/cloud/cloud_config_manager.cpp b/services/distributeddataservice/framework/cloud/cloud_config_manager.cpp new file mode 100644 index 000000000..e170b0716 --- /dev/null +++ b/services/distributeddataservice/framework/cloud/cloud_config_manager.cpp @@ -0,0 +1,49 @@ +/* +* 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. +*/ + +#define LOG_TAG "CloudConfigManager" +#include +#include "cloud/cloud_config_manager.h" + +namespace OHOS::DistributedData { +CloudConfigManager &CloudConfigManager::GetInstance() +{ + static CloudConfigManager instance; + return instance; +} + +void CloudConfigManager::Initialize(const std::vector &mapper) +{ + std::unique_lock lock(mutex_); + for (const auto &info : mapper) { + toLocalMapper_.insert_or_assign(info.cloudBundle, info.localBundle); + toCloudMapper_.insert_or_assign(info.localBundle, info.cloudBundle); + } +} + +std::string CloudConfigManager::ToLocal(const std::string &bundleName) +{ + std::shared_lock lock(mutex_); + auto it = toLocalMapper_.find(bundleName); + return it == toLocalMapper_.end() ? bundleName : it->second; +} + +std::string CloudConfigManager::ToCloud(const std::string &bundleName) +{ + std::shared_lock lock(mutex_); + auto it = toCloudMapper_.find(bundleName); + return it == toCloudMapper_.end() ? bundleName : it->second; +} +} // namespace OHOS::DistributedData \ No newline at end of file diff --git a/services/distributeddataservice/framework/include/checker/checker_manager.h b/services/distributeddataservice/framework/include/checker/checker_manager.h index 58628ecd8..9ad15fe2b 100644 --- a/services/distributeddataservice/framework/include/checker/checker_manager.h +++ b/services/distributeddataservice/framework/include/checker/checker_manager.h @@ -44,12 +44,12 @@ public: virtual std::string GetAppId(const StoreInfo &info) = 0; virtual bool IsValid(const StoreInfo &info) = 0; virtual bool IsDistrust(const StoreInfo &info) = 0; - virtual bool SetDynamicStores(const std::vector& storeInfos) = 0; - virtual bool SetStaticStores(const std::vector& storeInfos) = 0; + virtual bool AddDynamicStore(const StoreInfo& storeInfo) = 0; + virtual bool AddStaticStore(const StoreInfo& storeInfo) = 0; virtual std::vector GetDynamicStores() = 0; virtual std::vector GetStaticStores() = 0; - virtual bool IsDynamicStores(const StoreInfo &info) = 0; - virtual bool IsStaticStores(const StoreInfo &info) = 0; + virtual bool IsDynamic(const StoreInfo &info) = 0; + virtual bool IsStatic(const StoreInfo &info) = 0; protected: API_EXPORT ~Checker() = default; }; @@ -58,8 +58,8 @@ public: API_EXPORT std::string GetAppId(const StoreInfo &info); API_EXPORT std::vector GetDynamicStores(); API_EXPORT std::vector GetStaticStores(); - API_EXPORT bool IsDynamicStores(const StoreInfo &info); - API_EXPORT bool IsStaticStores(const StoreInfo &info); + API_EXPORT bool IsDynamic(const StoreInfo &info); + API_EXPORT bool IsStatic(const StoreInfo &info); API_EXPORT bool IsValid(const StoreInfo &info); API_EXPORT bool IsDistrust(const StoreInfo &info); API_EXPORT void LoadCheckers(std::vector &checkers); diff --git a/services/distributeddataservice/framework/include/cloud/cloud_config_manager.h b/services/distributeddataservice/framework/include/cloud/cloud_config_manager.h new file mode 100644 index 000000000..2082d9e9a --- /dev/null +++ b/services/distributeddataservice/framework/include/cloud/cloud_config_manager.h @@ -0,0 +1,43 @@ +/* +* 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 LDBPROJ_CLOUD_CONFIG_MANAGER_H +#define LDBPROJ_CLOUD_CONFIG_MANAGER_H +#include +#include +#include +#include +#include "visibility.h" +namespace OHOS { +namespace DistributedData { +class CloudConfigManager { +public: + struct Info { + std::string localBundle; + std::string cloudBundle; + }; + API_EXPORT static CloudConfigManager &GetInstance(); + API_EXPORT void Initialize(const std::vector &mapper); + API_EXPORT std::string ToLocal(const std::string &bundleName); + API_EXPORT std::string ToCloud(const std::string &bundleName); + +private: + std::map toLocalMapper_; + std::map toCloudMapper_; + std::shared_mutex mutex_; +}; + +} // namespace DistributedData +} // namespace OHOS +#endif //LDBPROJ_CLOUD_CONFIG_MANAGER_H diff --git a/services/distributeddataservice/service/BUILD.gn b/services/distributeddataservice/service/BUILD.gn index 80a3fac90..e628f7b00 100644 --- a/services/distributeddataservice/service/BUILD.gn +++ b/services/distributeddataservice/service/BUILD.gn @@ -84,6 +84,7 @@ ohos_shared_library("distributeddatasvc") { "config/src/config_factory.cpp", "config/src/model/backup_config.cpp", "config/src/model/checker_config.cpp", + "config/src/model/cloud_config.cpp", "config/src/model/component_config.cpp", "config/src/model/directory_config.cpp", "config/src/model/global_config.cpp", diff --git a/services/distributeddataservice/service/bootstrap/include/bootstrap.h b/services/distributeddataservice/service/bootstrap/include/bootstrap.h index c23012366..967ad0976 100644 --- a/services/distributeddataservice/service/bootstrap/include/bootstrap.h +++ b/services/distributeddataservice/service/bootstrap/include/bootstrap.h @@ -29,6 +29,7 @@ public: API_EXPORT void LoadCheckers(); API_EXPORT void LoadNetworks(); API_EXPORT void LoadDirectory(); + API_EXPORT void LoadCloud(); API_EXPORT void LoadBackup(std::shared_ptr executors); private: static constexpr const char *DEFAULT_LABEL = "distributeddata"; diff --git a/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp b/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp index ab8832b6f..185c0e342 100644 --- a/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp +++ b/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp @@ -20,6 +20,7 @@ #include "backup_manager.h" #include "backuprule/backup_rule_manager.h" #include "checker/checker_manager.h" +#include "cloud/cloud_config_manager.h" #include "config_factory.h" #include "directory/directory_manager.h" #include "log_print.h" @@ -100,6 +101,20 @@ void Bootstrap::LoadCheckers() } checker->SetDistrustInfo(distrust); } + for (const auto &dynamicStore : checkers->dynamicStores) { + auto *checker = CheckerManager::GetInstance().GetChecker(dynamicStore.checker); + if (checker == nullptr) { + continue; + } + checker->AddDynamicStore(dynamicStore); + } + for (const auto &staticStore : checkers->staticStores) { + auto *checker = CheckerManager::GetInstance().GetChecker(staticStore.checker); + if (checker == nullptr) { + continue; + } + checker->AddDynamicStore(staticStore); + } } void Bootstrap::LoadBackup(std::shared_ptr executors) @@ -132,5 +147,18 @@ void Bootstrap::LoadDirectory() } DirectoryManager::GetInstance().Initialize(strategies); } + +void Bootstrap::LoadCloud() +{ + auto *config = ConfigFactory::GetInstance().GetCloudConfig(); + if (config == nullptr) { + return; + } + std::vector infos; + for (auto &info : config->mapper) { + infos.push_back({ info.localBundle, info.cloudBundle }); + } + CloudConfigManager::GetInstance().Initialize(infos); +} } // namespace DistributedData } // namespace OHOS diff --git a/services/distributeddataservice/service/config/include/config_factory.h b/services/distributeddataservice/service/config/include/config_factory.h index 9961dbfd8..e6e4025c6 100644 --- a/services/distributeddataservice/service/config/include/config_factory.h +++ b/services/distributeddataservice/service/config/include/config_factory.h @@ -30,6 +30,7 @@ public: API_EXPORT GlobalConfig *GetGlobalConfig(); API_EXPORT DirectoryConfig *GetDirectoryConfig(); API_EXPORT BackupConfig *GetBackupConfig(); + API_EXPORT CloudConfig *GetCloudConfig(); private: static constexpr const char *CONF_PATH = "/system/etc/distributeddata/conf"; ConfigFactory(); diff --git a/services/distributeddataservice/service/config/include/model/checker_config.h b/services/distributeddataservice/service/config/include/model/checker_config.h index c4755d8ee..ad983f0d5 100644 --- a/services/distributeddataservice/service/config/include/model/checker_config.h +++ b/services/distributeddataservice/service/config/include/model/checker_config.h @@ -25,10 +25,18 @@ public: bool Marshal(json &node) const override; bool Unmarshal(const json &node) override; }; + struct StaticStore final : public Serializable, public CheckerManager::StoreInfo { + std::string checker; + bool Marshal(json &node) const override; + bool Unmarshal(const json &node) override; + }; using Distrust = Trust; + using DynamicStore = StaticStore; std::vector checkers; std::vector trusts; std::vector distrusts; + std::vector staticStores; + std::vector dynamicStores; bool Marshal(json &node) const override; bool Unmarshal(const json &node) override; }; diff --git a/services/distributeddataservice/service/config/include/model/cloud_config.h b/services/distributeddataservice/service/config/include/model/cloud_config.h new file mode 100644 index 000000000..34fafa396 --- /dev/null +++ b/services/distributeddataservice/service/config/include/model/cloud_config.h @@ -0,0 +1,35 @@ +/* +* 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 OHOS_DISTRIBUTED_DATA_SERVICES_CONFIG_MODEL_CLOUD_CONFIG_H +#define OHOS_DISTRIBUTED_DATA_SERVICES_CONFIG_MODEL_CLOUD_CONFIG_H + +#include "serializable/serializable.h" +namespace OHOS { +namespace DistributedData { +class CloudConfig final : public Serializable { +public: + struct Info final : public Serializable { + std::string localBundle; + std::string cloudBundle; + bool Marshal(json &node) const override; + bool Unmarshal(const json &node) override; + }; + std::vector mapper; + bool Marshal(json &node) const override; + bool Unmarshal(const json &node) override; +}; +} // namespace DistributedData +} // namespace OHOS +#endif //OHOS_DISTRIBUTED_DATA_SERVICES_CONFIG_MODEL_CLOUD_CONFIG_H diff --git a/services/distributeddataservice/service/config/include/model/global_config.h b/services/distributeddataservice/service/config/include/model/global_config.h index bf8e88668..c96926e4f 100644 --- a/services/distributeddataservice/service/config/include/model/global_config.h +++ b/services/distributeddataservice/service/config/include/model/global_config.h @@ -17,6 +17,7 @@ #define OHOS_DISTRIBUTED_DATA_SERVICES_CONFIG_MODEL_GLOBAL_CONFIG_H #include "serializable/serializable.h" #include "model/checker_config.h" +#include "model/cloud_config.h" #include "model/component_config.h" #include "model/network_config.h" #include "model/directory_config.h" @@ -34,6 +35,7 @@ public: NetworkConfig *networks = nullptr; DirectoryConfig *directory = nullptr; BackupConfig *backup = nullptr; + CloudConfig *cloud = nullptr; ~GlobalConfig(); bool Marshal(json &node) const override; bool Unmarshal(const json &node) override; diff --git a/services/distributeddataservice/service/config/src/config_factory.cpp b/services/distributeddataservice/service/config/src/config_factory.cpp index 411abf1a1..733ab0ea9 100644 --- a/services/distributeddataservice/service/config/src/config_factory.cpp +++ b/services/distributeddataservice/service/config/src/config_factory.cpp @@ -77,5 +77,10 @@ BackupConfig *ConfigFactory::GetBackupConfig() { return config_.backup; } + +CloudConfig *ConfigFactory::GetCloudConfig() +{ + return config_.cloud; +} } // namespace DistributedData } // namespace OHOS diff --git a/services/distributeddataservice/service/config/src/model/checker_config.cpp b/services/distributeddataservice/service/config/src/model/checker_config.cpp index f65f2d0d3..38450ec19 100644 --- a/services/distributeddataservice/service/config/src/model/checker_config.cpp +++ b/services/distributeddataservice/service/config/src/model/checker_config.cpp @@ -51,5 +51,24 @@ bool CheckerConfig::Unmarshal(const json &node) GetValue(node, GET_NAME(distrusts), distrusts); return true; } + +bool CheckerConfig::StaticStore::Marshal(Serializable::json &node) const +{ + SetValue(node[GET_NAME(uid)], uid); + SetValue(node[GET_NAME(tokenId)], tokenId); + SetValue(node[GET_NAME(bundleName)], bundleName); + SetValue(node[GET_NAME(storeId)], storeId); + SetValue(node[GET_NAME(checker)], checker); + return true; +} +bool CheckerConfig::StaticStore::Unmarshal(const Serializable::json &node) +{ + GetValue(node, GET_NAME(uid), uid); + GetValue(node, GET_NAME(tokenId), tokenId); + GetValue(node, GET_NAME(bundleName), bundleName); + GetValue(node, GET_NAME(storeId), storeId); + GetValue(node, GET_NAME(checker), checker); + return true; +} } // namespace DistributedData } // namespace OHOS diff --git a/services/distributeddataservice/service/config/src/model/cloud_config.cpp b/services/distributeddataservice/service/config/src/model/cloud_config.cpp new file mode 100644 index 000000000..12d840abf --- /dev/null +++ b/services/distributeddataservice/service/config/src/model/cloud_config.cpp @@ -0,0 +1,43 @@ +/* + * 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 "model/cloud_config.h" +namespace OHOS { +namespace DistributedData { +bool CloudConfig::Marshal(json &node) const +{ + SetValue(node[GET_NAME(mapper)], mapper); + return true; +} + +bool CloudConfig::Unmarshal(const json &node) +{ + GetValue(node, GET_NAME(mapper), mapper); + return true; +} + +bool CloudConfig::Info::Marshal(Serializable::json &node) const +{ + SetValue(node[GET_NAME(localBundle)], localBundle); + SetValue(node[GET_NAME(cloudBundle)], cloudBundle); + return true; +} +bool CloudConfig::Info::Unmarshal(const Serializable::json &node) +{ + GetValue(node, GET_NAME(localBundle), localBundle); + GetValue(node, GET_NAME(cloudBundle), cloudBundle); + return true; +} +} // namespace DistributedData +} // namespace OHOS diff --git a/services/distributeddataservice/service/config/src/model/global_config.cpp b/services/distributeddataservice/service/config/src/model/global_config.cpp index 65ab85a4c..b3078891e 100644 --- a/services/distributeddataservice/service/config/src/model/global_config.cpp +++ b/services/distributeddataservice/service/config/src/model/global_config.cpp @@ -27,6 +27,7 @@ bool GlobalConfig::Marshal(json &node) const SetValue(node[GET_NAME(networks)], networks); SetValue(node[GET_NAME(directory)], directory); SetValue(node[GET_NAME(backup)], backup); + SetValue(node[GET_NAME(cloud)], cloud); return true; } @@ -41,6 +42,7 @@ bool GlobalConfig::Unmarshal(const json &node) GetValue(node, GET_NAME(networks), networks); GetValue(node, GET_NAME(directory), directory); GetValue(node, GET_NAME(backup), backup); + GetValue(node, GET_NAME(cloud), cloud); return true; } @@ -51,6 +53,7 @@ GlobalConfig::~GlobalConfig() delete networks; delete directory; delete backup; + delete cloud; } } // namespace DistributedData } // namespace OHOS diff --git a/services/distributeddataservice/service/test/BUILD.gn b/services/distributeddataservice/service/test/BUILD.gn index 5c82a36cb..2eba37daf 100644 --- a/services/distributeddataservice/service/test/BUILD.gn +++ b/services/distributeddataservice/service/test/BUILD.gn @@ -423,12 +423,18 @@ ohos_unittest("UdmfRunTimeStoreTest") { ohos_unittest("WaterVersionManagerTest") { module_out_path = module_output_path + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } sources = [ "${data_service_path}/service/backup/src/backup_manager.cpp", "${data_service_path}/service/bootstrap/src/bootstrap.cpp", "${data_service_path}/service/config/src/config_factory.cpp", "${data_service_path}/service/config/src/model/backup_config.cpp", "${data_service_path}/service/config/src/model/checker_config.cpp", + "${data_service_path}/service/config/src/model/cloud_config.cpp", "${data_service_path}/service/config/src/model/component_config.cpp", "${data_service_path}/service/config/src/model/directory_config.cpp", "${data_service_path}/service/config/src/model/global_config.cpp", @@ -437,7 +443,7 @@ ohos_unittest("WaterVersionManagerTest") { "${data_service_path}/service/waterversion/water_version_manager.cpp", "mock/db_change_data_mock.cpp", "mock/db_store_mock.cpp", - "water_version_manager_test.cpp" + "water_version_manager_test.cpp", ] include_dirs = [ @@ -454,23 +460,27 @@ ohos_unittest("WaterVersionManagerTest") { "${data_service_path}/service/permission/include", "${data_service_path}/service/rdb", "${data_service_path}/service/waterversion", + "${data_service_path}/adapter/include/communicator", "${data_service_path}/adapter/include", "${data_service_path}/app/src", - "${data_service_path}/framework/include" + "${data_service_path}/framework/include", ] configs = [ ":module_private_config" ] external_deps = [ "access_token:libaccesstoken_sdk", + "access_token:libnativetoken", + "access_token:libtoken_setproc", "access_token:libtokenid_sdk", "c_utils:utils", "device_auth:deviceauth_sdk", "device_manager:devicemanagersdk", "dfs_service:cloudsync_asset_kit_inner", + "dsoftbus:softbus_client", "hilog:libhilog", - "huks:libhukssdk", "ipc:ipc_core", + "kv_store:distributeddata_inner", ] deps = [ @@ -600,6 +610,7 @@ ohos_unittest("DataShareServiceImplTest") { "//third_party/googletest:gtest_main", ] } + ############################################################################### group("unittest") { testonly = true diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/BUILD.gn index 09649a211..9f452e1b4 100644 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/BUILD.gn @@ -75,6 +75,7 @@ ohos_fuzztest("CloudServiceStubFuzzTest") { "${data_service_path}/service/config/src/config_factory.cpp", "${data_service_path}/service/config/src/model/backup_config.cpp", "${data_service_path}/service/config/src/model/checker_config.cpp", + "${data_service_path}/service/config/src/model/cloud_config.cpp", "${data_service_path}/service/config/src/model/component_config.cpp", "${data_service_path}/service/config/src/model/directory_config.cpp", "${data_service_path}/service/config/src/model/global_config.cpp", diff --git a/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/BUILD.gn index a85fde35f..c5473ec83 100644 --- a/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/BUILD.gn @@ -61,6 +61,7 @@ ohos_fuzztest("KvdbServiceStubFuzzTest") { "${data_service_path}/service/config/src/config_factory.cpp", "${data_service_path}/service/config/src/model/backup_config.cpp", "${data_service_path}/service/config/src/model/checker_config.cpp", + "${data_service_path}/service/config/src/model/cloud_config.cpp", "${data_service_path}/service/config/src/model/component_config.cpp", "${data_service_path}/service/config/src/model/directory_config.cpp", "${data_service_path}/service/config/src/model/global_config.cpp", diff --git a/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/BUILD.gn index e5e675113..4866d1d79 100644 --- a/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/BUILD.gn @@ -61,6 +61,7 @@ ohos_fuzztest("ObjectServiceStubFuzzTest") { "${data_service_path}/service/config/src/config_factory.cpp", "${data_service_path}/service/config/src/model/backup_config.cpp", "${data_service_path}/service/config/src/model/checker_config.cpp", + "${data_service_path}/service/config/src/model/cloud_config.cpp", "${data_service_path}/service/config/src/model/component_config.cpp", "${data_service_path}/service/config/src/model/directory_config.cpp", "${data_service_path}/service/config/src/model/global_config.cpp", diff --git a/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/BUILD.gn index a60805307..fc4a309ab 100644 --- a/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/BUILD.gn @@ -69,6 +69,7 @@ ohos_fuzztest("RdbServiceStubFuzzTest") { "${data_service_path}/service/config/src/config_factory.cpp", "${data_service_path}/service/config/src/model/backup_config.cpp", "${data_service_path}/service/config/src/model/checker_config.cpp", + "${data_service_path}/service/config/src/model/cloud_config.cpp", "${data_service_path}/service/config/src/model/component_config.cpp", "${data_service_path}/service/config/src/model/directory_config.cpp", "${data_service_path}/service/config/src/model/global_config.cpp", diff --git a/services/distributeddataservice/service/test/water_version_manager_test.cpp b/services/distributeddataservice/service/test/water_version_manager_test.cpp index 5f63fffc9..6f80ffceb 100644 --- a/services/distributeddataservice/service/test/water_version_manager_test.cpp +++ b/services/distributeddataservice/service/test/water_version_manager_test.cpp @@ -14,12 +14,15 @@ */ #include "water_version_manager.h" +#include "accesstoken_kit.h" +#include "executor_pool.h" +#include "nativetoken_kit.h" +#include "token_setproc.h" #include "checker/checker_manager.h" #include "block_data.h" #include "device_manager_adapter.h" #include "bootstrap.h" #include "gtest/gtest.h" -#include "ipc_skeleton.h" #include "metadata/meta_data_manager.h" #include "mock/db_store_mock.h" #include "serializable/serializable.h" @@ -29,10 +32,13 @@ using namespace OHOS::DistributedData; using DMAdapter = DeviceManagerAdapter; using namespace DistributedDB; using WaterVersionMetaData = WaterVersionManager::WaterVersionMetaData; +using namespace OHOS::Security::AccessToken; namespace OHOS::Test { namespace DistributedDataTest { class TestChecker; +static std::vector> stores_ = { { "bundle0", "store0" }, { "bundle1", "store0" }, + { "bundle2", "store0" } }; class WaterVersionManagerTest : public testing::Test { public: static void SetUpTestCase(void); @@ -41,13 +47,35 @@ public: void TearDown(); protected: - static constexpr const char *TEST_DEVICE = "14a0a92a428005db27c40bad46bf145fede38ec37effe0347cd990fcb031f320"; + static constexpr const char *testDevice = "14a0a92a428005db27c40bad46bf145fede38ec37effe0347cd990fcb031f320"; void InitMetaData(); static std::shared_ptr dbStoreMock_; static WaterVersionMetaData meta_; - static std::vector> stores_; + static TestChecker instance_; }; + +void GrantPermissionNative() +{ + const char **perms = new const char *[2]; + perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC"; + perms[1] = "ohos.permission.ACCESS_SERVICE_DM"; + TokenInfoParams infoInstance = { + .dcapsNum = 0, + .permsNum = 2, + .aclsNum = 0, + .dcaps = nullptr, + .perms = perms, + .acls = nullptr, + .processName = "WaterVersionManagerTest", + .aplStr = "system_basic", + }; + uint64_t tokenId = GetAccessTokenId(&infoInstance); + SetSelfTokenID(tokenId); + AccessTokenKit::ReloadNativeTokenInfo(); + delete []perms; +} + class TestChecker : public CheckerManager::Checker { public: TestChecker() noexcept @@ -56,7 +84,14 @@ public: "SystemChecker", [this]() -> auto { return this; }); } ~TestChecker() {} - void Initialize() override {} + void Initialize() override + { + staticInfos_.clear(); + dynamicInfos_.clear(); + for (auto &it : stores_) { + staticInfos_.push_back({ 0, 0, it.first, it.second }); + } + } bool SetTrustInfo(const CheckerManager::Trust &trust) override { return true; @@ -78,42 +113,58 @@ public: { return true; } - bool SetDynamicStores(const vector &storeInfos) override + vector GetDynamicStores() override { - return false; + return dynamicInfos_; } - bool SetStaticStores(const vector &storeInfos) override + vector GetStaticStores() override { - return false; + return staticInfos_; } - vector GetDynamicStores() override + bool IsDynamic(const CheckerManager::StoreInfo &info) override { - return {}; + for (const auto &store : dynamicInfos_) { + if (info.bundleName == store.bundleName && info.storeId == store.storeId) { + return true; + } + } + return false; } - vector GetStaticStores() override + bool IsStatic(const CheckerManager::StoreInfo &info) override { - return { { 0, 0, "bundle0", "store0" }, { 0, 0, "bundle1", "store0" }, { 0, 0, "bundle2", "store0" } }; + for (const auto &store : staticInfos_) { + if (info.bundleName == store.bundleName && info.storeId == store.storeId) { + return true; + } + } + return false; } - bool IsDynamicStores(const CheckerManager::StoreInfo &info) override + bool AddDynamicStore(const CheckerManager::StoreInfo &storeInfo) override { return false; } - bool IsStaticStores(const CheckerManager::StoreInfo &info) override + bool AddStaticStore(const CheckerManager::StoreInfo &storeInfo) override { return false; } + +private: + vector dynamicInfos_; + vector staticInfos_; }; -TestChecker instance_; +TestChecker WaterVersionManagerTest::instance_; std::shared_ptr WaterVersionManagerTest::dbStoreMock_ = std::make_shared(); WaterVersionMetaData WaterVersionManagerTest::meta_; -std::vector> WaterVersionManagerTest::stores_ = { { "bundle0", "store0" }, - { "bundle1", "store0" }, { "bundle2", "store0" } }; void WaterVersionManagerTest::SetUpTestCase(void) { + size_t max = 12; + size_t min = 5; + DeviceManagerAdapter::GetInstance().Init(std::make_shared(max, min)); + GrantPermissionNative(); Bootstrap::GetInstance().LoadCheckers(); MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr); - meta_.deviceId = TEST_DEVICE; + meta_.deviceId = testDevice; meta_.version = WaterVersionManager::WaterVersionMetaData::DEFAULT_VERSION; meta_.waterVersion = 0; meta_.type = WaterVersionManager::STATIC; @@ -121,7 +172,7 @@ void WaterVersionManagerTest::SetUpTestCase(void) for (auto &it : stores_) { meta_.keys.push_back(Constant::Join(it.first, Constant::KEY_SEPARATOR, { it.second })); } - meta_.infos = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } }; + meta_.infos = { meta_.keys.size(), std::vector(meta_.keys.size(), 0)}; } void WaterVersionManagerTest::TearDownTestCase(void) {} @@ -133,7 +184,7 @@ void WaterVersionManagerTest::SetUp() void WaterVersionManagerTest::TearDown() { - WaterVersionManager::GetInstance().DelWaterVersion(TEST_DEVICE); + WaterVersionManager::GetInstance().DelWaterVersion(testDevice); WaterVersionManager::GetInstance().DelWaterVersion(DMAdapter::GetInstance().GetLocalDevice().uuid); MetaDataManager::GetInstance().DelMeta(meta_.GetKey(), true); } @@ -154,7 +205,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest1, TestSize.Level0) { std::string waterVersion; ASSERT_TRUE( - WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, waterVersion)); + WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, waterVersion)); ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); WaterVersionManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); @@ -165,7 +216,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest1, TestSize.Level0) Serializable::Marshall(meta))) << Serializable::Marshall(meta); ASSERT_TRUE( - WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, waterVersion)); + WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, waterVersion)); ASSERT_EQ(Serializable::Marshall(meta), waterVersion); ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); @@ -183,7 +234,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest2, TestSize.Level0) { std::string waterVersion; ASSERT_TRUE( - WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, waterVersion)); + WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, waterVersion)); ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); WaterVersionManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); @@ -193,7 +244,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest2, TestSize.Level0) EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))); uint64_t version; - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); EXPECT_EQ(version, 1); // second store update @@ -201,7 +252,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest2, TestSize.Level0) meta.waterVersion = 2; EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, Serializable::Marshall(meta))); - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); EXPECT_EQ(version, 2); } @@ -216,7 +267,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest3, TestSize.Level0) { std::string waterVersion; ASSERT_TRUE( - WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, waterVersion)); + WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, waterVersion)); ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); WaterVersionManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); @@ -228,7 +279,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest3, TestSize.Level0) EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, Serializable::Marshall(meta))); uint64_t version; - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); EXPECT_EQ(version, 0); //bundle1 updated earlier, but sync later. update waterVersion @@ -236,7 +287,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest3, TestSize.Level0) meta.waterVersion = 1; EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))); - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); EXPECT_EQ(version, 2); } @@ -251,7 +302,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest4, TestSize.Level0) { std::string waterVersion; ASSERT_TRUE( - WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, waterVersion)); + WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, waterVersion)); ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); WaterVersionManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); @@ -263,7 +314,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest4, TestSize.Level0) EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))); uint64_t version; - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); EXPECT_EQ(version, 2); } @@ -278,7 +329,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest5, TestSize.Level0) { std::string waterVersion; ASSERT_TRUE( - WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, waterVersion)); + WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, waterVersion)); ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); WaterVersionManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); @@ -293,7 +344,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest5, TestSize.Level0) EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, Serializable::Marshall(meta))); uint64_t version; - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); EXPECT_EQ(version, 0); //2 sync @@ -303,7 +354,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest5, TestSize.Level0) meta.waterVersion = 4; EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[2].first, stores_[2].second, Serializable::Marshall(meta))); - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); EXPECT_EQ(version, 0); //0 sync @@ -313,7 +364,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest5, TestSize.Level0) meta.waterVersion = 3; EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))); - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(TEST_DEVICE, WaterVersionManager::STATIC, version)); + EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); EXPECT_EQ(version, 4); std::cout< WaterVersionManager::Split(const std::string res.push_back(key.substr(pos, found - pos)); pos = found + delim.size(); } - if (res.size() < 2) { + // The number of res should more than 1 + if (res.size() <= 1) { return { "", "" }; } return { res[0], res[1] }; diff --git a/services/distributeddataservice/service/waterversion/water_version_manager.h b/services/distributeddataservice/service/waterversion/water_version_manager.h index c18ddd578..c1d2f6344 100644 --- a/services/distributeddataservice/service/waterversion/water_version_manager.h +++ b/services/distributeddataservice/service/waterversion/water_version_manager.h @@ -74,8 +74,8 @@ private: std::pair Split(const std::string &key); static constexpr size_t MAX_DEVICES = 16; std::mutex mutex_; - std::vector staticKeys_;// = { "bundle0###store0", "bundle1###store0", "bundle2###store0" }; - std::vector dynamicKeys_;// = { "bundle0###store1", "bundle1###store1", "bundle4###store0" }; + std::vector staticKeys_; + std::vector dynamicKeys_; LRUBucket staticVersions_{ MAX_DEVICES }; LRUBucket dynamicVersions_{ MAX_DEVICES }; void UpdateWaterVersion(WaterVersionMetaData &metaData) const; -- Gitee From 0036af5aabeb108291d9ded109cce3fa541e8f18 Mon Sep 17 00:00:00 2001 From: htt1997 Date: Sun, 28 Apr 2024 10:45:26 +0800 Subject: [PATCH 3/7] refactor:waterVersion Signed-off-by: htt1997 --- .../framework/cloud/cloud_extra_data.cpp | 2 + .../service/cloud/cloud_service_stub.cpp | 17 +- .../test/water_version_manager_test.cpp | 206 +++++----- .../waterversion/water_version_manager.cpp | 365 +++++++++--------- .../waterversion/water_version_manager.h | 51 +-- 5 files changed, 329 insertions(+), 312 deletions(-) diff --git a/services/distributeddataservice/framework/cloud/cloud_extra_data.cpp b/services/distributeddataservice/framework/cloud/cloud_extra_data.cpp index fdd7f41e0..2527c69f1 100644 --- a/services/distributeddataservice/framework/cloud/cloud_extra_data.cpp +++ b/services/distributeddataservice/framework/cloud/cloud_extra_data.cpp @@ -14,6 +14,7 @@ */ #include "cloud/cloud_extra_data.h" +#include "cloud/cloud_config_manager.h" namespace OHOS::DistributedData { bool ExtensionInfo::Marshal(Serializable::json &node) const @@ -30,6 +31,7 @@ bool ExtensionInfo::Unmarshal(const Serializable::json &node) { GetValue(node, GET_NAME(accountId), accountId); GetValue(node, GET_NAME(bundleName), bundleName); + bundleName = CloudConfigManager::GetInstance().ToLocal(bundleName); GetValue(node, GET_NAME(containerName), containerName); GetValue(node, GET_NAME(databaseScopes), databaseScopes); if (!Unmarshall(databaseScopes, scopes)) { diff --git a/services/distributeddataservice/service/cloud/cloud_service_stub.cpp b/services/distributeddataservice/service/cloud/cloud_service_stub.cpp index 4aa3c79bd..d0874a223 100644 --- a/services/distributeddataservice/service/cloud/cloud_service_stub.cpp +++ b/services/distributeddataservice/service/cloud/cloud_service_stub.cpp @@ -17,6 +17,7 @@ #include "ipc_skeleton.h" #include "cloud_types_util.h" +#include "cloud/cloud_config_manager.h" #include "log_print.h" #include "permission/permission_validator.h" #include "rdb_types.h" @@ -86,7 +87,11 @@ int32_t CloudServiceStub::OnEnableCloud(MessageParcel &data, MessageParcel &repl ZLOGE("Unmarshal id:%{public}s", Anonymous::Change(id).c_str()); return IPC_STUB_INVALID_DATA_ERR; } - auto result = EnableCloud(id, switches); + std::map localSwitches; + for (auto &[bundle, status] : switches) { + localSwitches.insert_or_assign(CloudConfigManager::GetInstance().ToLocal(bundle), status); + } + auto result = EnableCloud(id, localSwitches); return ITypesUtil::Marshal(reply, result) ? ERR_NONE : IPC_STUB_WRITE_PARCEL_ERR; } @@ -110,7 +115,7 @@ int32_t CloudServiceStub::OnChangeAppSwitch(MessageParcel &data, MessageParcel & ZLOGE("Unmarshal id:%{public}s", Anonymous::Change(id).c_str()); return IPC_STUB_INVALID_DATA_ERR; } - auto result = ChangeAppSwitch(id, bundleName, appSwitch); + auto result = ChangeAppSwitch(id, CloudConfigManager::GetInstance().ToLocal(bundleName), appSwitch); return ITypesUtil::Marshal(reply, result) ? ERR_NONE : IPC_STUB_WRITE_PARCEL_ERR; } @@ -122,7 +127,11 @@ int32_t CloudServiceStub::OnClean(MessageParcel &data, MessageParcel &reply) ZLOGE("Unmarshal id:%{public}s", Anonymous::Change(id).c_str()); return IPC_STUB_INVALID_DATA_ERR; } - auto result = Clean(id, actions); + std::map localActions; + for (auto &[bundle, action] : actions) { + localActions.insert_or_assign(CloudConfigManager::GetInstance().ToLocal(bundle), action); + } + auto result = Clean(id, localActions); return ITypesUtil::Marshal(reply, result) ? ERR_NONE : IPC_STUB_WRITE_PARCEL_ERR; } @@ -134,7 +143,7 @@ int32_t CloudServiceStub::OnNotifyDataChange(MessageParcel &data, MessageParcel ZLOGE("Unmarshal id:%{public}s", Anonymous::Change(id).c_str()); return IPC_STUB_INVALID_DATA_ERR; } - auto result = NotifyDataChange(id, bundleName); + auto result = NotifyDataChange(id, CloudConfigManager::GetInstance().ToLocal(bundleName)); return ITypesUtil::Marshal(reply, result) ? ERR_NONE : IPC_STUB_WRITE_PARCEL_ERR; } diff --git a/services/distributeddataservice/service/test/water_version_manager_test.cpp b/services/distributeddataservice/service/test/water_version_manager_test.cpp index 6f80ffceb..60cda259c 100644 --- a/services/distributeddataservice/service/test/water_version_manager_test.cpp +++ b/services/distributeddataservice/service/test/water_version_manager_test.cpp @@ -15,24 +15,25 @@ #include "water_version_manager.h" #include "accesstoken_kit.h" -#include "executor_pool.h" -#include "nativetoken_kit.h" -#include "token_setproc.h" -#include "checker/checker_manager.h" #include "block_data.h" -#include "device_manager_adapter.h" #include "bootstrap.h" +#include "checker/checker_manager.h" +#include "device_manager_adapter.h" +#include "executor_pool.h" #include "gtest/gtest.h" #include "metadata/meta_data_manager.h" #include "mock/db_store_mock.h" +#include "nativetoken_kit.h" #include "serializable/serializable.h" +#include "token_setproc.h" #include "utils/constant.h" using namespace testing::ext; using namespace OHOS::DistributedData; -using DMAdapter = DeviceManagerAdapter; using namespace DistributedDB; -using WaterVersionMetaData = WaterVersionManager::WaterVersionMetaData; using namespace OHOS::Security::AccessToken; +using WvManager = WaterVersionManager; +using DMAdapter = DeviceManagerAdapter; +using WaterVersionMetaData = WvManager::WaterVersionMetaData; namespace OHOS::Test { namespace DistributedDataTest { @@ -48,6 +49,7 @@ public: protected: static constexpr const char *testDevice = "14a0a92a428005db27c40bad46bf145fede38ec37effe0347cd990fcb031f320"; + static void GrantPermissionNative(); void InitMetaData(); static std::shared_ptr dbStoreMock_; @@ -55,7 +57,7 @@ protected: static TestChecker instance_; }; -void GrantPermissionNative() +void WaterVersionManagerTest::GrantPermissionNative() { const char **perms = new const char *[2]; perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC"; @@ -73,7 +75,7 @@ void GrantPermissionNative() uint64_t tokenId = GetAccessTokenId(&infoInstance); SetSelfTokenID(tokenId); AccessTokenKit::ReloadNativeTokenInfo(); - delete []perms; + delete[] perms; } class TestChecker : public CheckerManager::Checker { @@ -165,14 +167,14 @@ void WaterVersionManagerTest::SetUpTestCase(void) MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr); meta_.deviceId = testDevice; - meta_.version = WaterVersionManager::WaterVersionMetaData::DEFAULT_VERSION; + meta_.version = WvManager::WaterVersionMetaData::DEFAULT_VERSION; meta_.waterVersion = 0; - meta_.type = WaterVersionManager::STATIC; + meta_.type = WvManager::STATIC; meta_.keys.clear(); for (auto &it : stores_) { meta_.keys.push_back(Constant::Join(it.first, Constant::KEY_SEPARATOR, { it.second })); } - meta_.infos = { meta_.keys.size(), std::vector(meta_.keys.size(), 0)}; + meta_.infos = { meta_.keys.size(), std::vector(meta_.keys.size(), 0) }; } void WaterVersionManagerTest::TearDownTestCase(void) {} @@ -184,8 +186,8 @@ void WaterVersionManagerTest::SetUp() void WaterVersionManagerTest::TearDown() { - WaterVersionManager::GetInstance().DelWaterVersion(testDevice); - WaterVersionManager::GetInstance().DelWaterVersion(DMAdapter::GetInstance().GetLocalDevice().uuid); + WvManager::GetInstance().DelWaterVersion(testDevice); + WvManager::GetInstance().DelWaterVersion(DMAdapter::GetInstance().GetLocalDevice().uuid); MetaDataManager::GetInstance().DelMeta(meta_.GetKey(), true); } @@ -203,24 +205,22 @@ void WaterVersionManagerTest::InitMetaData() */ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest1, TestSize.Level0) { - std::string waterVersion; - ASSERT_TRUE( - WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, waterVersion)); - ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); - WaterVersionManager::WaterVersionMetaData meta; + std::string waterVersion = WvManager::GetInstance().GetWaterVersion(testDevice, WvManager::STATIC); + ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)) << "meta: " << waterVersion; + WvManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); meta.infos[0] = { 1, 0, 0 }; meta.waterVersion = 1; - EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, - Serializable::Marshall(meta))) + EXPECT_TRUE( + WvManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))) << Serializable::Marshall(meta); - ASSERT_TRUE( - WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, waterVersion)); - ASSERT_EQ(Serializable::Marshall(meta), waterVersion); - ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); - EXPECT_EQ(meta.GetVersion(), 1) << "meta: " << meta.ToAnonymousString(); + waterVersion = WvManager::GetInstance().GetWaterVersion(testDevice, WvManager::STATIC); + ASSERT_EQ(Serializable::Marshall(meta), waterVersion); + auto [success, version] = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + EXPECT_TRUE(success && version == 1) + << "success:" << success << " version:" << version << " meta: " << meta.ToAnonymousString(); } /** @@ -232,27 +232,24 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest1, TestSize.Level0) */ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest2, TestSize.Level0) { - std::string waterVersion; - ASSERT_TRUE( - WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, waterVersion)); - ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); - WaterVersionManager::WaterVersionMetaData meta; + std::string waterVersion = WvManager::GetInstance().GetWaterVersion(testDevice, WvManager::STATIC); + ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)) << "meta: " << waterVersion; + WvManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); // first store update meta.infos[0] = { 1, 0, 0 }; meta.waterVersion = 1; - EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, - Serializable::Marshall(meta))); - uint64_t version; - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); + EXPECT_TRUE( + WvManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))); + auto [_, version] = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); EXPECT_EQ(version, 1); // second store update meta.infos[1] = { 1, 2, 0 }; meta.waterVersion = 2; - EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, - Serializable::Marshall(meta))); - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); + EXPECT_TRUE( + WvManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, Serializable::Marshall(meta))); + std::tie(_, version) = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); EXPECT_EQ(version, 2); } @@ -265,30 +262,29 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest2, TestSize.Level0) */ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest3, TestSize.Level0) { - std::string waterVersion; - ASSERT_TRUE( - WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, waterVersion)); - ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); - WaterVersionManager::WaterVersionMetaData meta; + std::string waterVersion = WvManager::GetInstance().GetWaterVersion(testDevice, WvManager::STATIC); + ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)) << "meta: " << waterVersion; + WvManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); EXPECT_EQ(meta.GetVersion(), 0) << "meta: " << Serializable::Marshall(meta); //bundle2 updated later, but sync first. Do not update waterVersion meta.infos[1] = { 1, 2, 0 }; meta.waterVersion = 2; - EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, - Serializable::Marshall(meta))); - uint64_t version; - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); - EXPECT_EQ(version, 0); + EXPECT_TRUE( + WvManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, Serializable::Marshall(meta))); + auto res = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + EXPECT_TRUE(res.first && res.second == 0) + << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString(); //bundle1 updated earlier, but sync later. update waterVersion meta.infos[0] = { 1, 0, 0 }; meta.waterVersion = 1; - EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, - Serializable::Marshall(meta))); - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); - EXPECT_EQ(version, 2); + EXPECT_TRUE( + WvManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))); + res = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + EXPECT_TRUE(res.first && res.second == 2) + << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString(); } /** @@ -300,22 +296,21 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest3, TestSize.Level0) */ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest4, TestSize.Level0) { - std::string waterVersion; - ASSERT_TRUE( - WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, waterVersion)); - ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); - WaterVersionManager::WaterVersionMetaData meta; + std::string waterVersion = WvManager::GetInstance().GetWaterVersion(testDevice, WvManager::STATIC); + ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)) << "meta: " << waterVersion; + WvManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); EXPECT_EQ(meta.GetVersion(), 0) << "meta: " << Serializable::Marshall(meta); //bundle1 updated twice, but sync once. update waterVersion meta.infos[0] = { 2, 0, 0 }; meta.waterVersion = 2; - EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, - Serializable::Marshall(meta))); - uint64_t version; - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); - EXPECT_EQ(version, 2); + EXPECT_TRUE( + WvManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))); + + auto res = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + EXPECT_TRUE(res.first && res.second == 2) + << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString(); } /** @@ -327,11 +322,9 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest4, TestSize.Level0) */ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest5, TestSize.Level0) { - std::string waterVersion; - ASSERT_TRUE( - WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, waterVersion)); - ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)); - WaterVersionManager::WaterVersionMetaData meta; + std::string waterVersion = WvManager::GetInstance().GetWaterVersion(testDevice, WvManager::STATIC); + ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)) << "meta: " << waterVersion; + WvManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); EXPECT_EQ(meta.GetVersion(), 0) << "meta: " << Serializable::Marshall(meta); @@ -341,32 +334,34 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest5, TestSize.Level0) meta.infos[1] = { 1, 2, 0 }; meta.infos[2] = { 0, 0, 0 }; meta.waterVersion = 2; - EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, - Serializable::Marshall(meta))); - uint64_t version; - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); - EXPECT_EQ(version, 0); + EXPECT_TRUE( + WvManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, Serializable::Marshall(meta))); + + auto res = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + EXPECT_TRUE(res.first && res.second == 0) + << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString(); //2 sync meta.infos[0] = { 3, 2, 0 }; meta.infos[1] = { 1, 2, 0 }; meta.infos[2] = { 3, 2, 4 }; meta.waterVersion = 4; - EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[2].first, stores_[2].second, - Serializable::Marshall(meta))); - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); - EXPECT_EQ(version, 0); + EXPECT_TRUE( + WvManager::GetInstance().SetWaterVersion(stores_[2].first, stores_[2].second, Serializable::Marshall(meta))); + res = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + EXPECT_TRUE(res.first && res.second == 0) + << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString(); //0 sync meta.infos[0] = { 3, 2, 0 }; meta.infos[1] = { 1, 2, 0 }; meta.infos[2] = { 0, 0, 0 }; meta.waterVersion = 3; - EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, - Serializable::Marshall(meta))); - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); - EXPECT_EQ(version, 4); - std::cout<(5, 5); for (int i = 0; i < 10; ++i) { executorPool->Execute([] { - WaterVersionManager::GetInstance().GenerateWaterVersion(stores_[0].first, stores_[0].second); + WvManager::GetInstance().GenerateWaterVersion(stores_[0].first, stores_[0].second, WvManager::STATIC); }); } std::this_thread::sleep_for(std::chrono::milliseconds(1000)); - uint64_t version; - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(DMAdapter::GetInstance().GetLocalDevice().uuid, - WaterVersionManager::STATIC, version)); + auto [success, version] = + WvManager::GetInstance().GetVersion(DMAdapter::GetInstance().GetLocalDevice().uuid, WvManager::STATIC); EXPECT_EQ(version, 10); } @@ -426,21 +422,19 @@ HWTEST_F(WaterVersionManagerTest, GenerateWaterVersionTest2, TestSize.Level0) HWTEST_F(WaterVersionManagerTest, MixCallTest1, TestSize.Level0) { std::string waterVersion = - WaterVersionManager::GetInstance().GenerateWaterVersion(stores_[0].first, stores_[0].second); - WaterVersionManager::WaterVersionMetaData meta; + WvManager::GetInstance().GenerateWaterVersion(stores_[0].first, stores_[0].second, WvManager::STATIC); + WvManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)) << "waterVersion: " << waterVersion; EXPECT_EQ(meta.waterVersion, 1) << "waterVersion: " << waterVersion; meta.deviceId = testDevice; - EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, - Serializable::Marshall(meta))); + EXPECT_TRUE( + WvManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))); - uint64_t version; - EXPECT_TRUE(WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); - EXPECT_EQ(version, 1) << "waterVersion: " << waterVersion; + auto [_, version] = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + EXPECT_EQ(version, 1) << "version: " << version; } - /** * @tc.name: MixCallTest2 * @tc.desc: use GenerateWaterVersion to SetWaterVersion and GenerateWaterVersion more than once @@ -450,21 +444,21 @@ HWTEST_F(WaterVersionManagerTest, MixCallTest1, TestSize.Level0) */ HWTEST_F(WaterVersionManagerTest, MixCallTest2, TestSize.Level0) { + bool success = false; + uint64_t version = 0; for (int i = 1; i < 11; ++i) { - std::string waterVersion = - WaterVersionManager::GetInstance().GenerateWaterVersion(stores_[i % meta_.keys.size()].first, - stores_[i % meta_.keys.size()].second); - WaterVersionManager::WaterVersionMetaData meta; + std::string waterVersion = WvManager::GetInstance().GenerateWaterVersion(stores_[i % meta_.keys.size()].first, + stores_[i % meta_.keys.size()].second, WvManager::STATIC); + WvManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)) << "waterVersion: " << waterVersion; EXPECT_EQ(meta.waterVersion, i) << "waterVersion: " << waterVersion; meta.deviceId = testDevice; - EXPECT_TRUE(WaterVersionManager::GetInstance().SetWaterVersion(stores_[i % meta_.keys.size()].first, + EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(stores_[i % meta_.keys.size()].first, stores_[i % meta_.keys.size()].second, Serializable::Marshall(meta))); - uint64_t version; - EXPECT_TRUE( - WaterVersionManager::GetInstance().GetWaterVersion(testDevice, WaterVersionManager::STATIC, version)); - EXPECT_EQ(version, i) << "waterVersion: " << waterVersion; + std::tie(success, version) = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + EXPECT_TRUE(success && version == i) + << "i:" << i << " success:" << success << " version:" << version << " meta: " << meta.ToAnonymousString(); } } } // namespace DistributedDataTest diff --git a/services/distributeddataservice/service/waterversion/water_version_manager.cpp b/services/distributeddataservice/service/waterversion/water_version_manager.cpp index a1b0609f9..48b45eeab 100644 --- a/services/distributeddataservice/service/waterversion/water_version_manager.cpp +++ b/services/distributeddataservice/service/waterversion/water_version_manager.cpp @@ -26,82 +26,67 @@ namespace OHOS::DistributedData { using DMAdapter = DeviceManagerAdapter; +using WaterVersionMetaData = WaterVersionManager::WaterVersionMetaData; WaterVersionManager &WaterVersionManager::GetInstance() { static WaterVersionManager waterVersionManager; return waterVersionManager; } -WaterVersionManager::WaterVersionManager() +WaterVersionManager::WaterVersionManager() : waterVersions_(BUTT) { std::vector metas; auto stores = CheckerManager::GetInstance().GetDynamicStores(); + for (int i = 0; i < BUTT; ++i) { + waterVersions_[i].SetType(static_cast(i)); + } for (const auto &store : stores) { - dynamicKeys_.push_back(Merge(store.bundleName, store.storeId)); + waterVersions_[DYNAMIC].AddKey(Merge(store.bundleName, store.storeId)); } stores = CheckerManager::GetInstance().GetStaticStores(); for (const auto &store : stores) { - staticKeys_.push_back(Merge(store.bundleName, store.storeId)); + waterVersions_[STATIC].AddKey(Merge(store.bundleName, store.storeId)); } MetaDataManager::GetInstance().LoadMeta(WaterVersionMetaData::GetPrefix(), metas, true); for (auto &meta : metas) { - if (meta.type == DYNAMIC) { - if (dynamicKeys_ != meta.keys || meta.version != WaterVersionMetaData::DEFAULT_VERSION) { - meta = Upgrade(dynamicKeys_, meta); - } - dynamicVersions_.Set(meta.deviceId, meta); - MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true); - } - if (meta.type == STATIC) { - if (staticKeys_ != meta.keys || meta.version != WaterVersionMetaData::DEFAULT_VERSION) { - meta = Upgrade(staticKeys_, meta); - } - staticVersions_.Set(meta.deviceId, meta); - MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true); + if (meta.type < 0 || meta.type > BUTT) { + ZLOGW("error meta:%{public}s", meta.ToAnonymousString().c_str()); + continue; } + waterVersions_[meta.type].InitWaterVersion(meta); } } -std::string WaterVersionManager::GenerateWaterVersion(const std::string &bundleName, const std::string &storeName) +std::string WaterVersionManager::GenerateWaterVersion(const std::string &bundleName, const std::string &storeName, + Type type) { - WaterVersionMetaData meta; - std::string key = Merge(bundleName, storeName); - for (size_t i = 0; i < staticKeys_.size(); ++i) { - if (staticKeys_[i] == key) { - meta.type = STATIC; - meta.keys = staticKeys_; - return InnerGenerate(i, staticVersions_, meta) ? Serializable::Marshall(meta) : ""; - } - } - for (size_t i = 0; i < dynamicKeys_.size(); ++i) { - if (dynamicKeys_[i] == key) { - meta.type = DYNAMIC; - meta.keys = dynamicKeys_; - return InnerGenerate(i, dynamicVersions_, meta) ? Serializable::Marshall(meta) : ""; - } + if (type < 0 || type >= BUTT || bundleName.empty() || storeName.empty()) { + ZLOGE("invalid args. bundleName:%{public}s, storeName:%{public}s, type:%{public}d", bundleName.c_str(), + Anonymous::Change(storeName).c_str(), type); + return ""; } - ZLOGE("invalid param. bundleName:%{public}s, storeName:%{public}s", bundleName.c_str(), storeName.c_str()); - return ""; + auto [success, meta] = waterVersions_[type].GenerateWaterVersion(Merge(bundleName, storeName)); + return success ? Serializable::Marshall(meta) : ""; } -bool WaterVersionManager::GetWaterVersion(const std::string &deviceId, WaterVersionManager::Type type, - std::string &waterVersion) +std::pair WaterVersionManager::GetVersion(const std::string &deviceId, + WaterVersionManager::Type type) { - WaterVersionMetaData meta; - if (InnerGetWaterVersion(deviceId, type, meta)) { - waterVersion = Serializable::Marshall(meta); - return true; + if (type < 0 || type >= BUTT || deviceId.empty()) { + ZLOGE("invalid args, type:%{public}d", type); + return { false, 0 }; } - return false; + auto [success, waterVersion] = waterVersions_[type].GetWaterVersion(deviceId); + return { success, success ? waterVersion.waterVersion : 0 }; } -bool WaterVersionManager::GetWaterVersion(const std::string &deviceId, WaterVersionManager::Type type, - uint64_t &waterVersion) + +std::string WaterVersionManager::GetWaterVersion(const std::string &deviceId, WaterVersionManager::Type type) { - WaterVersionMetaData meta; - if (InnerGetWaterVersion(deviceId, type, meta)) { - waterVersion = meta.GetVersion(); - return true; + if (type < 0 || type >= BUTT || deviceId.empty()) { + ZLOGE("invalid args, type:%{public}d", type); + return { false, 0 }; } - return false; + auto [success, waterVersion] = waterVersions_[type].GetWaterVersion(deviceId); + return success ? Serializable::Marshall(waterVersion) : ""; } bool WaterVersionManager::SetWaterVersion(const std::string &bundleName, const std::string &storeName, @@ -110,134 +95,24 @@ bool WaterVersionManager::SetWaterVersion(const std::string &bundleName, const s WaterVersionMetaData metaData; if (!Serializable::Unmarshall(waterVersion, metaData) || metaData.deviceId.empty() || !metaData.IsValid() || metaData.deviceId == DMAdapter::GetInstance().GetLocalDevice().uuid) { - ZLOGE("invalid param. meta:%{public}s, bundleName:%{public}s, storeName:%{public}s", + ZLOGE("invalid args. meta:%{public}s, bundleName:%{public}s, storeName:%{public}s", metaData.ToAnonymousString().c_str(), bundleName.c_str(), Anonymous::Change(storeName).c_str()); return false; } std::string key = Merge(bundleName, storeName); - for (size_t i = 0; i < staticKeys_.size(); ++i) { - if (metaData.type != STATIC) { - break; - } - if (staticKeys_[i] == key) { - return InnerSetWaterVersion(key, metaData, staticVersions_); - } - } - for (size_t i = 0; i < dynamicKeys_.size(); ++i) { - if (metaData.type != DYNAMIC) { - break; - } - if (dynamicKeys_[i] == key) { - return InnerSetWaterVersion(key, metaData, dynamicVersions_); - } - } ZLOGE("error key. deviceId:%{public}s, bundleName:%{public}s, storeName:%{public}s", Anonymous::Change(metaData.deviceId).c_str(), bundleName.c_str(), Anonymous::Change(storeName).c_str()); - return false; + return waterVersions_[metaData.type].SetWaterVersion(Merge(bundleName, storeName), metaData); } bool WaterVersionManager::DelWaterVersion(const std::string &deviceId) { - WaterVersionMetaData meta; - if (dynamicVersions_.Get(deviceId, meta)) { - dynamicVersions_.Delete(deviceId); - MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true); + bool res = true; + for (auto &waterVersion : waterVersions_) { + res = res && waterVersion.DelWaterVersion(deviceId); } - if (staticVersions_.Get(deviceId, meta)) { - staticVersions_.Delete(deviceId); - MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true); - } - return true; -} - -bool WaterVersionManager::InnerGenerate(int index, LRUBucket &bucket, - WaterVersionMetaData &metaData) -{ - metaData.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid; - if (metaData.deviceId.empty()) { - ZLOGE("GetLocalDevice failed!"); - return false; - } - metaData.infos = { metaData.keys.size(), std::vector(metaData.keys.size(), 0) }; - // ensure serial execution - std::lock_guard lock(mutex_); - auto status = bucket.Get(metaData.deviceId, metaData); - if (!status && !MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData, true)) { - ZLOGW("no WaterVersion, start InitMeta"); - InitMeta(metaData); - } - metaData.waterVersion++; - // It has been initialized above, so there is no need to check for out of bounds - metaData.infos[index][index] = metaData.waterVersion; - for (size_t i = 0; i < metaData.keys.size(); ++i) { - metaData.infos[index][i] = metaData.infos[i][i]; - } - MetaDataManager::GetInstance().SaveMeta(metaData.GetKey(), metaData, true); - ZLOGI("generate meta:%{public}s", metaData.ToAnonymousString().c_str()); - return bucket.Set(DMAdapter::GetInstance().GetLocalDevice().uuid, metaData); -} - -bool WaterVersionManager::InnerGetWaterVersion(const std::string &deviceId, WaterVersionManager::Type type, - WaterVersionManager::WaterVersionMetaData &meta) -{ - if (deviceId.empty() || type < 0 || type > DYNAMIC) { - ZLOGE("invalid param. deviceId:%{public}s, type:%{public}d", Anonymous::Change(deviceId).c_str(), type); - return false; - } - meta.type = type; - meta.deviceId = deviceId; - bool flag = false; - switch (type) { - case DYNAMIC: - flag = dynamicVersions_.Get(deviceId, meta); - break; - case STATIC: - flag = staticVersions_.Get(deviceId, meta); - break; - default: - ZLOGE("error type:%{public}d. deviceId:%{public}s", type, Anonymous::Change(deviceId).c_str()); - return false; - } - if (!flag && MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { - type == DYNAMIC ? dynamicVersions_.Set(deviceId, meta) : staticVersions_.Set(deviceId, meta); - } - ZLOGI("get meta:%{public}s, flag:%{public}d", meta.ToAnonymousString().c_str(), flag); - return true; -} - -bool WaterVersionManager::InnerSetWaterVersion(const std::string &key, - const WaterVersionMetaData &metaData, LRUBucket &bucket) -{ - WaterVersionMetaData oldMeta; - std::lock_guard lock(mutex_); - bool success = bucket.Get(metaData.deviceId, oldMeta); - if (!success && !MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), oldMeta, true)) { - ZLOGI("save meta:%{public}s", metaData.ToAnonymousString().c_str()); - return MetaDataManager::GetInstance().SaveMeta(oldMeta.GetKey(), metaData, true) && - bucket.Set(metaData.deviceId, metaData); - } - if (oldMeta.keys.size() != metaData.keys.size() || oldMeta.version != metaData.version) { - ZLOGI("upgrade meta. old:%{public}s, new:%{public}s", oldMeta.ToAnonymousString().c_str(), - metaData.ToAnonymousString().c_str()); - oldMeta = metaData; - for (size_t i = 0; i < metaData.keys.size(); ++i) { - // Set all unSync items to 0 - if (metaData.keys[i] != key) { - oldMeta.infos[i] = std::vector(metaData.keys.size(), 0); - } - } - } else { - for (size_t i = 0; i < oldMeta.keys.size(); ++i) { - if (oldMeta.keys[i] == key) { - oldMeta.infos[i] = metaData.infos[i]; - break; - } - } - } - UpdateWaterVersion(oldMeta); - return MetaDataManager::GetInstance().SaveMeta(oldMeta.GetKey(), oldMeta, true) && - bucket.Set(metaData.deviceId, oldMeta); + return res; } bool WaterVersionManager::InitMeta(WaterVersionMetaData &metaData) @@ -252,20 +127,21 @@ bool WaterVersionManager::InitMeta(WaterVersionMetaData &metaData) storeMetaData.instanceId = 0; if (!MetaDataManager::GetInstance().LoadMeta(storeMetaData.GetKey(), storeMetaData, true)) { ZLOGE("no store! bundleName:%{public}s, storeName:%{public}s", storeMetaData.bundleName.c_str(), - storeMetaData.storeId.c_str()); + storeMetaData.GetStoreAlias().c_str()); continue; } auto store = AutoCache::GetInstance().GetStore(storeMetaData, {}); if (store == nullptr) { ZLOGE("store is null! bundleName:%{public}s, storeName:%{public}s", storeMetaData.bundleName.c_str(), - storeMetaData.storeId.c_str()); + storeMetaData.GetStoreAlias().c_str()); continue; } auto waterVersion = store->GetWaterVersion(uuid); WaterVersionMetaData meta; if (waterVersion.empty() || !Serializable::Unmarshall(waterVersion, meta)) { ZLOGE("GetWaterVersion failed! bundleName:%{public}s, storeName:%{public}s, meta:%{public}s", - storeMetaData.bundleName.c_str(), storeMetaData.storeId.c_str(), meta.ToAnonymousString().c_str()); + storeMetaData.bundleName.c_str(), storeMetaData.GetStoreAlias().c_str(), + meta.ToAnonymousString().c_str()); continue; } if (meta.version != metaData.version || meta.keys != metaData.keys) { @@ -276,7 +152,8 @@ bool WaterVersionManager::InitMeta(WaterVersionMetaData &metaData) UpdateWaterVersion(metaData); return true; } -void WaterVersionManager::UpdateWaterVersion(WaterVersionManager::WaterVersionMetaData &metaData) const + +void WaterVersionManager::UpdateWaterVersion(WaterVersionMetaData &metaData) { ZLOGI("before update meta:%{public}s", metaData.ToAnonymousString().c_str()); for (size_t i = 0; i < metaData.keys.size(); ++i) { @@ -318,8 +195,8 @@ std::pair WaterVersionManager::Split(const std::string return { res[0], res[1] }; } -WaterVersionManager::WaterVersionMetaData WaterVersionManager::Upgrade(const std::vector &keys, - const WaterVersionManager::WaterVersionMetaData &meta) +WaterVersionMetaData WaterVersionManager::Upgrade(const std::vector &keys, + const WaterVersionMetaData &meta) { WaterVersionMetaData newMeta; newMeta.keys = keys; @@ -333,6 +210,7 @@ WaterVersionManager::WaterVersionMetaData WaterVersionManager::Upgrade(const std for (size_t j = 0; j < meta.keys.size(); ++j) { if (meta.keys[j] == keys[i]) { mp[j] = i; + continue; } } } @@ -349,7 +227,8 @@ WaterVersionManager::WaterVersionMetaData WaterVersionManager::Upgrade(const std } return newMeta; } -bool WaterVersionManager::WaterVersionMetaData::Marshal(Serializable::json &node) const + +bool WaterVersionMetaData::Marshal(Serializable::json &node) const { SetValue(node[GET_NAME(deviceId)], deviceId); SetValue(node[GET_NAME(version)], version); @@ -359,14 +238,15 @@ bool WaterVersionManager::WaterVersionMetaData::Marshal(Serializable::json &node SetValue(node[GET_NAME(infos)], infos); return true; } -bool WaterVersionManager::WaterVersionMetaData::Unmarshal(const Serializable::json &node) + +bool WaterVersionMetaData::Unmarshal(const Serializable::json &node) { GetValue(node, GET_NAME(deviceId), deviceId); GetValue(node, GET_NAME(version), version); GetValue(node, GET_NAME(waterVersion), waterVersion); int32_t tmp = -1; GetValue(node, GET_NAME(type), tmp); - if (tmp < 0 || tmp > DYNAMIC) { + if (tmp < 0 || tmp >= BUTT) { return false; } type = static_cast(tmp); @@ -374,28 +254,35 @@ bool WaterVersionManager::WaterVersionMetaData::Unmarshal(const Serializable::js GetValue(node, GET_NAME(infos), infos); return true; } -std::string WaterVersionManager::WaterVersionMetaData::ToAnonymousString() const + +std::string WaterVersionMetaData::ToAnonymousString() const { json root; Marshal(root); SetValue(root[GET_NAME(deviceId)], Anonymous::Change(deviceId)); return root.dump(-1, ' ', false, error_handler_t::replace); } -std::string WaterVersionManager::WaterVersionMetaData::GetKey() const + +std::string WaterVersionMetaData::GetKey() const { return Constant::Join(KEY_PREFIX, Constant::KEY_SEPARATOR, { deviceId, std::to_string(type) }); } -uint64_t WaterVersionManager::WaterVersionMetaData::GetVersion() + +uint64_t WaterVersionMetaData::GetVersion() { return waterVersion; } -std::string WaterVersionManager::WaterVersionMetaData::GetPrefix() + +std::string WaterVersionMetaData::GetPrefix() { return KEY_PREFIX; } -bool WaterVersionManager::WaterVersionMetaData::IsValid() +bool WaterVersionMetaData::IsValid() { + if (type < 0 || type >= BUTT) { + return false; + } if (keys.size() != infos.size()) { return false; } @@ -406,4 +293,126 @@ bool WaterVersionManager::WaterVersionMetaData::IsValid() } return true; } + +void WaterVersionManager::WaterVersion::SetType(WaterVersionManager::Type type) +{ + type_ = type; +} + +void WaterVersionManager::WaterVersion::AddKey(const std::string &key) +{ + keys_.push_back(key); +} + +std::pair WaterVersionManager::WaterVersion::GenerateWaterVersion(const std::string &key) +{ + WaterVersionMetaData metaData; + for (size_t i = 0; i < keys_.size(); ++i) { + if (keys_[i] != key) { + continue; + } + metaData.type = STATIC; + metaData.keys = keys_; + metaData.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid; + if (metaData.deviceId.empty()) { + ZLOGE("GetLocalDevice failed!"); + break; + } + metaData.infos = { metaData.keys.size(), std::vector(metaData.keys.size(), 0) }; + // ensure serial execution + std::lock_guard lock(mutex_); + auto status = versions_.Get(metaData.deviceId, metaData); + if (!status && !MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData, true)) { + ZLOGW("no WaterVersion, start InitMeta"); + InitMeta(metaData); + } + metaData.waterVersion++; + // It has been initialized above, so there is no need to check for out of bounds + metaData.infos[i][i] = metaData.waterVersion; + for (size_t j = 0; j < metaData.keys.size(); ++j) { + metaData.infos[i][j] = metaData.infos[j][j]; + } + ZLOGI("generate meta:%{public}s", metaData.ToAnonymousString().c_str()); + return { MetaDataManager::GetInstance().SaveMeta(metaData.GetKey(), metaData, true) && + versions_.Set(DMAdapter::GetInstance().GetLocalDevice().uuid, metaData), + metaData }; + } + return { false, metaData }; +} + +std::pair WaterVersionManager::WaterVersion::GetWaterVersion(const std::string &deviceId) +{ + WaterVersionMetaData meta; + if (versions_.Get(deviceId, meta)) { + return { true, meta }; + } + meta.deviceId = deviceId; + meta.type = type_; + if (MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) { + versions_.Set(deviceId, meta); + return { true, meta }; + } + return { false, meta }; +} + +bool WaterVersionManager::WaterVersion::SetWaterVersion(const std::string &key, + const WaterVersionMetaData &metaData) +{ + if (std::find(keys_.begin(), keys_.end(), key) == keys_.end()) { + ZLOGE("invalid key:%{public}s", metaData.ToAnonymousString().c_str()); + return false; + } + WaterVersionMetaData oldMeta; + // ensure serial execution + std::lock_guard lock(mutex_); + if (!versions_.Get(metaData.deviceId, oldMeta) && + !MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), oldMeta, true)) { + ZLOGI("save meta:%{public}s", metaData.ToAnonymousString().c_str()); + oldMeta = metaData; + UpdateWaterVersion(oldMeta); + return MetaDataManager::GetInstance().SaveMeta(oldMeta.GetKey(), oldMeta, true) && + versions_.Set(metaData.deviceId, oldMeta); + } + if (oldMeta.keys.size() != metaData.keys.size() || oldMeta.version != metaData.version) { + ZLOGI("upgrade meta. old:%{public}s, new:%{public}s", oldMeta.ToAnonymousString().c_str(), + metaData.ToAnonymousString().c_str()); + oldMeta = metaData; + for (size_t i = 0; i < metaData.keys.size(); ++i) { + // Set all unSync items to 0 + if (metaData.keys[i] != key) { + oldMeta.infos[i] = std::vector(metaData.keys.size(), 0); + } + } + } else { + for (size_t i = 0; i < oldMeta.keys.size(); ++i) { + if (oldMeta.keys[i] == key) { + oldMeta.infos[i] = metaData.infos[i]; + break; + } + } + } + UpdateWaterVersion(oldMeta); + return MetaDataManager::GetInstance().SaveMeta(oldMeta.GetKey(), oldMeta, true) && + versions_.Set(metaData.deviceId, oldMeta); +} + +bool WaterVersionManager::WaterVersion::DelWaterVersion(const std::string &deviceId) +{ + WaterVersionMetaData meta; + if (versions_.Get(deviceId, meta)) { + return versions_.Delete(deviceId) && MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true); + } + return true; +} + +bool WaterVersionManager::WaterVersion::InitWaterVersion(const WaterVersionMetaData &metaData) +{ + if (keys_ != metaData.keys || metaData.version != WaterVersionMetaData::DEFAULT_VERSION) { + auto meta = Upgrade(keys_, metaData); + MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true); + versions_.Set(meta.deviceId, meta); + } + versions_.Set(metaData.deviceId, metaData); + return true; +} } // namespace OHOS::DistributedData diff --git a/services/distributeddataservice/service/waterversion/water_version_manager.h b/services/distributeddataservice/service/waterversion/water_version_manager.h index c1d2f6344..b9b6c40f9 100644 --- a/services/distributeddataservice/service/waterversion/water_version_manager.h +++ b/services/distributeddataservice/service/waterversion/water_version_manager.h @@ -25,8 +25,9 @@ namespace DistributedData { class WaterVersionManager { public: enum Type { + DYNAMIC, STATIC, - DYNAMIC + BUTT }; class WaterVersionMetaData final : public Serializable { public: @@ -50,35 +51,37 @@ public: }; static WaterVersionManager &GetInstance(); WaterVersionManager(); - // 生成本地水位 - std::string GenerateWaterVersion(const std::string &bundleName, const std::string &storeName); - // 根据deviceId和type获取水位 - bool GetWaterVersion(const std::string &deviceId, Type type, std::string &waterVersion); - // 根据deviceId和type获取水位 - bool GetWaterVersion(const std::string &deviceId, Type type, uint64_t &waterVersion); - // 更新其它设备水位 + std::string GenerateWaterVersion(const std::string &bundleName, const std::string &storeName, Type type); + std::pair GetVersion(const std::string &deviceId, Type type); + std::string GetWaterVersion(const std::string &deviceId, Type type); bool SetWaterVersion(const std::string &bundleName, const std::string &storeName, const std::string &waterVersion); - // 删除水位 bool DelWaterVersion(const std::string &deviceId); private: - bool InnerGenerate(int index, LRUBucket &bucket, - WaterVersionMetaData &metaData); - bool InnerGetWaterVersion(const std::string &deviceId, Type type, WaterVersionMetaData &waterVersion); - bool InnerSetWaterVersion(const std::string &key, const WaterVersionMetaData &waterVersionMetaData, - LRUBucket &bucket); - bool InitMeta(WaterVersionMetaData &); - WaterVersionMetaData Upgrade(const std::vector &keys, const WaterVersionMetaData& meta); - std::string Merge(const std::string &bundleName, const std::string &storeName); - std::pair Split(const std::string &key); static constexpr size_t MAX_DEVICES = 16; - std::mutex mutex_; - std::vector staticKeys_; - std::vector dynamicKeys_; - LRUBucket staticVersions_{ MAX_DEVICES }; - LRUBucket dynamicVersions_{ MAX_DEVICES }; - void UpdateWaterVersion(WaterVersionMetaData &metaData) const; + class WaterVersion { + public: + WaterVersion() = default; + void SetType(Type type); + void AddKey(const std::string &key); + bool InitWaterVersion(const WaterVersionMetaData &metaData); + std::pair GenerateWaterVersion(const std::string &key); + std::pair GetWaterVersion(const std::string &deviceId); + bool SetWaterVersion(const std::string &key, const WaterVersionMetaData &metaData); + bool DelWaterVersion(const std::string &deviceId); + private: + Type type_; + std::mutex mutex_; + std::vector keys_; + LRUBucket versions_{ MAX_DEVICES }; + }; + static bool InitMeta(WaterVersionMetaData &); + static WaterVersionMetaData Upgrade(const std::vector &keys, const WaterVersionMetaData& meta); + static std::string Merge(const std::string &bundleName, const std::string &storeName); + static std::pair Split(const std::string &key); + static void UpdateWaterVersion(WaterVersionMetaData &metaData); + std::vector waterVersions_; }; } // namespace DistributedData } // namespace OHOS -- Gitee From 04c9a37f91867fcb4caf9c7fd0e2908009bc8642 Mon Sep 17 00:00:00 2001 From: htt1997 Date: Mon, 29 Apr 2024 17:54:02 +0800 Subject: [PATCH 4/7] fix bug Signed-off-by: htt1997 --- .../service/bootstrap/src/bootstrap.cpp | 2 +- .../config/src/model/checker_config.cpp | 4 + .../service/kvdb/kvdb_general_store.cpp | 6 ++ .../service/kvdb/kvdb_general_store.h | 1 + .../test/water_version_manager_test.cpp | 95 ++++++++++--------- .../waterversion/water_version_manager.cpp | 11 ++- .../waterversion/water_version_manager.h | 1 + 7 files changed, 73 insertions(+), 47 deletions(-) diff --git a/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp b/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp index 185c0e342..714faa69f 100644 --- a/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp +++ b/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp @@ -113,7 +113,7 @@ void Bootstrap::LoadCheckers() if (checker == nullptr) { continue; } - checker->AddDynamicStore(staticStore); + checker->AddStaticStore(staticStore); } } diff --git a/services/distributeddataservice/service/config/src/model/checker_config.cpp b/services/distributeddataservice/service/config/src/model/checker_config.cpp index 38450ec19..6a6f858df 100644 --- a/services/distributeddataservice/service/config/src/model/checker_config.cpp +++ b/services/distributeddataservice/service/config/src/model/checker_config.cpp @@ -41,6 +41,8 @@ bool CheckerConfig::Marshal(json &node) const SetValue(node[GET_NAME(checkers)], checkers); SetValue(node[GET_NAME(trusts)], trusts); SetValue(node[GET_NAME(distrusts)], distrusts); + SetValue(node[GET_NAME(staticStores)], staticStores); + SetValue(node[GET_NAME(dynamicStores)], dynamicStores); return true; } @@ -49,6 +51,8 @@ bool CheckerConfig::Unmarshal(const json &node) GetValue(node, GET_NAME(checkers), checkers); GetValue(node, GET_NAME(trusts), trusts); GetValue(node, GET_NAME(distrusts), distrusts); + GetValue(node, GET_NAME(staticStores), staticStores); + GetValue(node, GET_NAME(dynamicStores), dynamicStores); return true; } diff --git a/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp b/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp index 3005117a2..15d204f18 100644 --- a/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp +++ b/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp @@ -482,6 +482,12 @@ int32_t KVDBGeneralStore::UnregisterDetailProgressObserver() return GenErr::E_OK; } + +std::string KVDBGeneralStore::GetWaterVersion(const std::string &deviceId) +{ + return ""; +} + void KVDBGeneralStore::ObserverProxy::OnChange(DBOrigin origin, const std::string &originalId, DBChangeData &&data) { if (!HasWatcher()) { diff --git a/services/distributeddataservice/service/kvdb/kvdb_general_store.h b/services/distributeddataservice/service/kvdb/kvdb_general_store.h index 0a91022ac..5da022a65 100644 --- a/services/distributeddataservice/service/kvdb/kvdb_general_store.h +++ b/services/distributeddataservice/service/kvdb/kvdb_general_store.h @@ -70,6 +70,7 @@ public: int32_t Release() override; int32_t BindSnapshots(std::shared_ptr>> bindAssets) override; int32_t MergeMigratedData(const std::string &tableName, VBuckets &&values) override; + std::string GetWaterVersion(const std::string &deviceId) override; static DBPassword GetDBPassword(const StoreMetaData &data); static DBOption GetDBOption(const StoreMetaData &data, const DBPassword &password); diff --git a/services/distributeddataservice/service/test/water_version_manager_test.cpp b/services/distributeddataservice/service/test/water_version_manager_test.cpp index 60cda259c..c0436737e 100644 --- a/services/distributeddataservice/service/test/water_version_manager_test.cpp +++ b/services/distributeddataservice/service/test/water_version_manager_test.cpp @@ -48,12 +48,13 @@ public: void TearDown(); protected: - static constexpr const char *testDevice = "14a0a92a428005db27c40bad46bf145fede38ec37effe0347cd990fcb031f320"; + static constexpr const char *TEST_DEVICE = "14a0a92a428005db27c40bad46bf145fede38ec37effe0347cd990fcb031f320"; static void GrantPermissionNative(); void InitMetaData(); static std::shared_ptr dbStoreMock_; - static WaterVersionMetaData meta_; + static WaterVersionMetaData dynamicMeta_; + static WaterVersionMetaData staticMeta_; static TestChecker instance_; }; @@ -92,6 +93,7 @@ public: dynamicInfos_.clear(); for (auto &it : stores_) { staticInfos_.push_back({ 0, 0, it.first, it.second }); + dynamicInfos_.push_back({ 0, 0, it.first, it.second }); } } bool SetTrustInfo(const CheckerManager::Trust &trust) override @@ -156,7 +158,8 @@ private: }; TestChecker WaterVersionManagerTest::instance_; std::shared_ptr WaterVersionManagerTest::dbStoreMock_ = std::make_shared(); -WaterVersionMetaData WaterVersionManagerTest::meta_; +WaterVersionMetaData WaterVersionManagerTest::staticMeta_; +WaterVersionMetaData WaterVersionManagerTest::dynamicMeta_; void WaterVersionManagerTest::SetUpTestCase(void) { size_t max = 12; @@ -166,15 +169,17 @@ void WaterVersionManagerTest::SetUpTestCase(void) Bootstrap::GetInstance().LoadCheckers(); MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr); - meta_.deviceId = testDevice; - meta_.version = WvManager::WaterVersionMetaData::DEFAULT_VERSION; - meta_.waterVersion = 0; - meta_.type = WvManager::STATIC; - meta_.keys.clear(); + staticMeta_.deviceId = TEST_DEVICE; + staticMeta_.version = WvManager::WaterVersionMetaData::DEFAULT_VERSION; + staticMeta_.waterVersion = 0; + staticMeta_.type = WvManager::STATIC; + staticMeta_.keys.clear(); for (auto &it : stores_) { - meta_.keys.push_back(Constant::Join(it.first, Constant::KEY_SEPARATOR, { it.second })); + staticMeta_.keys.push_back(Constant::Join(it.first, Constant::KEY_SEPARATOR, { it.second })); } - meta_.infos = { meta_.keys.size(), std::vector(meta_.keys.size(), 0) }; + staticMeta_.infos = { staticMeta_.keys.size(), std::vector(staticMeta_.keys.size(), 0) }; + dynamicMeta_ = staticMeta_; + dynamicMeta_.type = WvManager::DYNAMIC; } void WaterVersionManagerTest::TearDownTestCase(void) {} @@ -186,14 +191,16 @@ void WaterVersionManagerTest::SetUp() void WaterVersionManagerTest::TearDown() { - WvManager::GetInstance().DelWaterVersion(testDevice); + WvManager::GetInstance().DelWaterVersion(TEST_DEVICE); WvManager::GetInstance().DelWaterVersion(DMAdapter::GetInstance().GetLocalDevice().uuid); - MetaDataManager::GetInstance().DelMeta(meta_.GetKey(), true); + MetaDataManager::GetInstance().DelMeta(staticMeta_.GetKey(), true); + MetaDataManager::GetInstance().DelMeta(dynamicMeta_.GetKey(), true); } void WaterVersionManagerTest::InitMetaData() { - MetaDataManager::GetInstance().SaveMeta(meta_.GetKey(), meta_, true); + MetaDataManager::GetInstance().SaveMeta(staticMeta_.GetKey(), staticMeta_, true); + MetaDataManager::GetInstance().SaveMeta(dynamicMeta_.GetKey(), dynamicMeta_, true); } /** @@ -205,8 +212,8 @@ void WaterVersionManagerTest::InitMetaData() */ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest1, TestSize.Level0) { - std::string waterVersion = WvManager::GetInstance().GetWaterVersion(testDevice, WvManager::STATIC); - ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)) << "meta: " << waterVersion; + std::string waterVersion = WvManager::GetInstance().GetWaterVersion(TEST_DEVICE, WvManager::STATIC); + ASSERT_EQ(waterVersion, Serializable::Marshall(staticMeta_)) << "meta: " << waterVersion; WvManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); meta.infos[0] = { 1, 0, 0 }; @@ -216,9 +223,9 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest1, TestSize.Level0) WvManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))) << Serializable::Marshall(meta); - waterVersion = WvManager::GetInstance().GetWaterVersion(testDevice, WvManager::STATIC); + waterVersion = WvManager::GetInstance().GetWaterVersion(TEST_DEVICE, WvManager::STATIC); ASSERT_EQ(Serializable::Marshall(meta), waterVersion); - auto [success, version] = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + auto [success, version] = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::STATIC); EXPECT_TRUE(success && version == 1) << "success:" << success << " version:" << version << " meta: " << meta.ToAnonymousString(); } @@ -232,8 +239,8 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest1, TestSize.Level0) */ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest2, TestSize.Level0) { - std::string waterVersion = WvManager::GetInstance().GetWaterVersion(testDevice, WvManager::STATIC); - ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)) << "meta: " << waterVersion; + std::string waterVersion = WvManager::GetInstance().GetWaterVersion(TEST_DEVICE, WvManager::STATIC); + ASSERT_EQ(waterVersion, Serializable::Marshall(staticMeta_)) << "meta: " << waterVersion; WvManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); // first store update @@ -241,7 +248,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest2, TestSize.Level0) meta.waterVersion = 1; EXPECT_TRUE( WvManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))); - auto [_, version] = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + auto [_, version] = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::STATIC); EXPECT_EQ(version, 1); // second store update @@ -249,7 +256,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest2, TestSize.Level0) meta.waterVersion = 2; EXPECT_TRUE( WvManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, Serializable::Marshall(meta))); - std::tie(_, version) = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + std::tie(_, version) = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::STATIC); EXPECT_EQ(version, 2); } @@ -262,8 +269,8 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest2, TestSize.Level0) */ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest3, TestSize.Level0) { - std::string waterVersion = WvManager::GetInstance().GetWaterVersion(testDevice, WvManager::STATIC); - ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)) << "meta: " << waterVersion; + std::string waterVersion = WvManager::GetInstance().GetWaterVersion(TEST_DEVICE, WvManager::DYNAMIC); + ASSERT_EQ(waterVersion, Serializable::Marshall(dynamicMeta_)) << "meta: " << waterVersion; WvManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); EXPECT_EQ(meta.GetVersion(), 0) << "meta: " << Serializable::Marshall(meta); @@ -273,7 +280,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest3, TestSize.Level0) meta.waterVersion = 2; EXPECT_TRUE( WvManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, Serializable::Marshall(meta))); - auto res = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + auto res = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::STATIC); EXPECT_TRUE(res.first && res.second == 0) << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString(); @@ -282,7 +289,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest3, TestSize.Level0) meta.waterVersion = 1; EXPECT_TRUE( WvManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))); - res = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + res = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::DYNAMIC); EXPECT_TRUE(res.first && res.second == 2) << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString(); } @@ -296,8 +303,8 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest3, TestSize.Level0) */ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest4, TestSize.Level0) { - std::string waterVersion = WvManager::GetInstance().GetWaterVersion(testDevice, WvManager::STATIC); - ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)) << "meta: " << waterVersion; + std::string waterVersion = WvManager::GetInstance().GetWaterVersion(TEST_DEVICE, WvManager::STATIC); + ASSERT_EQ(waterVersion, Serializable::Marshall(staticMeta_)) << "meta: " << waterVersion; WvManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); EXPECT_EQ(meta.GetVersion(), 0) << "meta: " << Serializable::Marshall(meta); @@ -308,7 +315,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest4, TestSize.Level0) EXPECT_TRUE( WvManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))); - auto res = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + auto res = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::STATIC); EXPECT_TRUE(res.first && res.second == 2) << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString(); } @@ -322,8 +329,9 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest4, TestSize.Level0) */ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest5, TestSize.Level0) { - std::string waterVersion = WvManager::GetInstance().GetWaterVersion(testDevice, WvManager::STATIC); - ASSERT_EQ(waterVersion, Serializable::Marshall(meta_)) << "meta: " << waterVersion; + auto type = WvManager::DYNAMIC; + std::string waterVersion = WvManager::GetInstance().GetWaterVersion(TEST_DEVICE, type); + ASSERT_EQ(waterVersion, Serializable::Marshall(dynamicMeta_)) << "meta: " << waterVersion; WvManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)); EXPECT_EQ(meta.GetVersion(), 0) << "meta: " << Serializable::Marshall(meta); @@ -337,7 +345,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest5, TestSize.Level0) EXPECT_TRUE( WvManager::GetInstance().SetWaterVersion(stores_[1].first, stores_[1].second, Serializable::Marshall(meta))); - auto res = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + auto res = WvManager::GetInstance().GetVersion(TEST_DEVICE, type); EXPECT_TRUE(res.first && res.second == 0) << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString(); @@ -348,7 +356,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest5, TestSize.Level0) meta.waterVersion = 4; EXPECT_TRUE( WvManager::GetInstance().SetWaterVersion(stores_[2].first, stores_[2].second, Serializable::Marshall(meta))); - res = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + res = WvManager::GetInstance().GetVersion(TEST_DEVICE, type); EXPECT_TRUE(res.first && res.second == 0) << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString(); @@ -359,7 +367,7 @@ HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest5, TestSize.Level0) meta.waterVersion = 3; EXPECT_TRUE( WvManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))); - res = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + res = WvManager::GetInstance().GetVersion(TEST_DEVICE, type); EXPECT_TRUE(res.first && res.second == 4) << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString(); } @@ -402,13 +410,13 @@ HWTEST_F(WaterVersionManagerTest, GenerateWaterVersionTest2, TestSize.Level0) auto executorPool = std::make_shared(5, 5); for (int i = 0; i < 10; ++i) { executorPool->Execute([] { - WvManager::GetInstance().GenerateWaterVersion(stores_[0].first, stores_[0].second, WvManager::STATIC); + WvManager::GetInstance().GenerateWaterVersion(stores_[0].first, stores_[0].second, WvManager::DYNAMIC); }); } std::this_thread::sleep_for(std::chrono::milliseconds(1000)); auto [success, version] = - WvManager::GetInstance().GetVersion(DMAdapter::GetInstance().GetLocalDevice().uuid, WvManager::STATIC); + WvManager::GetInstance().GetVersion(DMAdapter::GetInstance().GetLocalDevice().uuid, WvManager::DYNAMIC); EXPECT_EQ(version, 10); } @@ -427,11 +435,11 @@ HWTEST_F(WaterVersionManagerTest, MixCallTest1, TestSize.Level0) ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)) << "waterVersion: " << waterVersion; EXPECT_EQ(meta.waterVersion, 1) << "waterVersion: " << waterVersion; - meta.deviceId = testDevice; + meta.deviceId = TEST_DEVICE; EXPECT_TRUE( WvManager::GetInstance().SetWaterVersion(stores_[0].first, stores_[0].second, Serializable::Marshall(meta))); - auto [_, version] = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + auto [_, version] = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::STATIC); EXPECT_EQ(version, 1) << "version: " << version; } @@ -447,16 +455,17 @@ HWTEST_F(WaterVersionManagerTest, MixCallTest2, TestSize.Level0) bool success = false; uint64_t version = 0; for (int i = 1; i < 11; ++i) { - std::string waterVersion = WvManager::GetInstance().GenerateWaterVersion(stores_[i % meta_.keys.size()].first, - stores_[i % meta_.keys.size()].second, WvManager::STATIC); + int index = i % dynamicMeta_.keys.size(); + std::string waterVersion = WvManager::GetInstance().GenerateWaterVersion(stores_[index].first, + stores_[index].second, WvManager::DYNAMIC); WvManager::WaterVersionMetaData meta; ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)) << "waterVersion: " << waterVersion; EXPECT_EQ(meta.waterVersion, i) << "waterVersion: " << waterVersion; - meta.deviceId = testDevice; - EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(stores_[i % meta_.keys.size()].first, - stores_[i % meta_.keys.size()].second, Serializable::Marshall(meta))); + meta.deviceId = TEST_DEVICE; + EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(stores_[index].first, stores_[index].second, + Serializable::Marshall(meta))); - std::tie(success, version) = WvManager::GetInstance().GetVersion(testDevice, WvManager::STATIC); + std::tie(success, version) = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::DYNAMIC); EXPECT_TRUE(success && version == i) << "i:" << i << " success:" << success << " version:" << version << " meta: " << meta.ToAnonymousString(); } diff --git a/services/distributeddataservice/service/waterversion/water_version_manager.cpp b/services/distributeddataservice/service/waterversion/water_version_manager.cpp index 48b45eeab..675261fe1 100644 --- a/services/distributeddataservice/service/waterversion/water_version_manager.cpp +++ b/services/distributeddataservice/service/waterversion/water_version_manager.cpp @@ -35,11 +35,15 @@ WaterVersionManager &WaterVersionManager::GetInstance() } WaterVersionManager::WaterVersionManager() : waterVersions_(BUTT) { - std::vector metas; - auto stores = CheckerManager::GetInstance().GetDynamicStores(); for (int i = 0; i < BUTT; ++i) { waterVersions_[i].SetType(static_cast(i)); } +} + +void WaterVersionManager::Init() +{ + std::vector metas; + auto stores = CheckerManager::GetInstance().GetDynamicStores(); for (const auto &store : stores) { waterVersions_[DYNAMIC].AddKey(Merge(store.bundleName, store.storeId)); } @@ -56,6 +60,7 @@ WaterVersionManager::WaterVersionManager() : waterVersions_(BUTT) waterVersions_[meta.type].InitWaterVersion(meta); } } + std::string WaterVersionManager::GenerateWaterVersion(const std::string &bundleName, const std::string &storeName, Type type) { @@ -311,7 +316,7 @@ std::pair WaterVersionManager::WaterVersion::Generat if (keys_[i] != key) { continue; } - metaData.type = STATIC; + metaData.type = type_; metaData.keys = keys_; metaData.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid; if (metaData.deviceId.empty()) { diff --git a/services/distributeddataservice/service/waterversion/water_version_manager.h b/services/distributeddataservice/service/waterversion/water_version_manager.h index b9b6c40f9..d2836629c 100644 --- a/services/distributeddataservice/service/waterversion/water_version_manager.h +++ b/services/distributeddataservice/service/waterversion/water_version_manager.h @@ -51,6 +51,7 @@ public: }; static WaterVersionManager &GetInstance(); WaterVersionManager(); + void Init(); std::string GenerateWaterVersion(const std::string &bundleName, const std::string &storeName, Type type); std::pair GetVersion(const std::string &deviceId, Type type); std::string GetWaterVersion(const std::string &deviceId, Type type); -- Gitee From 4df9d4030b89fdf031ddb8c4b16d70a37dc15106 Mon Sep 17 00:00:00 2001 From: htt1997 Date: Tue, 30 Apr 2024 12:33:29 +0800 Subject: [PATCH 5/7] refactor:name Signed-off-by: htt1997 --- .../include/cloud/cloud_config_manager.h | 32 +++++++++---------- .../framework/include/store/general_store.h | 2 +- .../waterversion/water_version_manager.cpp | 3 ++ .../waterversion/water_version_manager.h | 1 + 4 files changed, 21 insertions(+), 17 deletions(-) diff --git a/services/distributeddataservice/framework/include/cloud/cloud_config_manager.h b/services/distributeddataservice/framework/include/cloud/cloud_config_manager.h index 2082d9e9a..94f21f466 100644 --- a/services/distributeddataservice/framework/include/cloud/cloud_config_manager.h +++ b/services/distributeddataservice/framework/include/cloud/cloud_config_manager.h @@ -1,19 +1,19 @@ /* -* 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 LDBPROJ_CLOUD_CONFIG_MANAGER_H -#define LDBPROJ_CLOUD_CONFIG_MANAGER_H + * 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 OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_CLOUD_CLOUD_CONFIG_MANAGER_H +#define OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_CLOUD_CLOUD_CONFIG_MANAGER_H #include #include #include @@ -40,4 +40,4 @@ private: } // namespace DistributedData } // namespace OHOS -#endif //LDBPROJ_CLOUD_CONFIG_MANAGER_H +#endif //OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_CLOUD_CLOUD_CONFIG_MANAGER_H diff --git a/services/distributeddataservice/framework/include/store/general_store.h b/services/distributeddataservice/framework/include/store/general_store.h index ba2c6842d..df45b56e8 100644 --- a/services/distributeddataservice/framework/include/store/general_store.h +++ b/services/distributeddataservice/framework/include/store/general_store.h @@ -137,7 +137,7 @@ public: virtual int32_t BindSnapshots(std::shared_ptr>> bindAssets) = 0; - virtual int32_t MergeMigratedData(const std::string &tableName, VBuckets&& values) = 0; + virtual int32_t MergeMigratedData(const std::string &tableName, VBuckets &&values) = 0; virtual std::string GetWaterVersion(const std::string &deviceId) = 0; }; diff --git a/services/distributeddataservice/service/waterversion/water_version_manager.cpp b/services/distributeddataservice/service/waterversion/water_version_manager.cpp index 675261fe1..15a55c0dc 100644 --- a/services/distributeddataservice/service/waterversion/water_version_manager.cpp +++ b/services/distributeddataservice/service/waterversion/water_version_manager.cpp @@ -332,6 +332,9 @@ std::pair WaterVersionManager::WaterVersion::Generat InitMeta(metaData); } metaData.waterVersion++; + if ((metaData.waterVersion & INVALID_VERSION) == INVALID_VERSION) { + metaData.waterVersion++; + } // It has been initialized above, so there is no need to check for out of bounds metaData.infos[i][i] = metaData.waterVersion; for (size_t j = 0; j < metaData.keys.size(); ++j) { diff --git a/services/distributeddataservice/service/waterversion/water_version_manager.h b/services/distributeddataservice/service/waterversion/water_version_manager.h index d2836629c..2bd77eea9 100644 --- a/services/distributeddataservice/service/waterversion/water_version_manager.h +++ b/services/distributeddataservice/service/waterversion/water_version_manager.h @@ -72,6 +72,7 @@ private: bool SetWaterVersion(const std::string &key, const WaterVersionMetaData &metaData); bool DelWaterVersion(const std::string &deviceId); private: + static constexpr uint16_t INVALID_VERSION = 0xFFF; Type type_; std::mutex mutex_; std::vector keys_; -- Gitee From 3c130d9eb55a9eee6573fab84c12e897aed7cb5e Mon Sep 17 00:00:00 2001 From: htt1997 Date: Tue, 30 Apr 2024 16:46:13 +0800 Subject: [PATCH 6/7] feature:add water version update Signed-off-by: htt1997 --- .../distributeddataservice/framework/BUILD.gn | 1 + .../cloud/cloud_sync_finished_event.cpp | 28 +++++++++ .../framework/include/cloud/cloud_event.h | 1 + .../include/cloud/cloud_sync_finished_event.h | 34 +++++++++++ .../include/metadata/store_meta_data.h | 1 + .../framework/include/store/general_store.h | 2 +- .../framework/metadata/store_meta_data.cpp | 10 ++++ .../service/bootstrap/src/bootstrap.cpp | 2 + .../service/kvdb/kvdb_general_store.cpp | 58 ++++++++++++++++++- .../service/kvdb/kvdb_general_store.h | 5 +- .../service/rdb/rdb_general_store.cpp | 4 +- .../service/rdb/rdb_general_store.h | 2 +- .../waterversion/water_version_manager.cpp | 42 +++++++++----- .../waterversion/water_version_manager.h | 26 ++++----- 14 files changed, 181 insertions(+), 35 deletions(-) create mode 100644 services/distributeddataservice/framework/cloud/cloud_sync_finished_event.cpp create mode 100644 services/distributeddataservice/framework/include/cloud/cloud_sync_finished_event.h diff --git a/services/distributeddataservice/framework/BUILD.gn b/services/distributeddataservice/framework/BUILD.gn index 6d27470fc..3ddb2e8e5 100644 --- a/services/distributeddataservice/framework/BUILD.gn +++ b/services/distributeddataservice/framework/BUILD.gn @@ -58,6 +58,7 @@ ohos_shared_library("distributeddatasvcfwk") { "cloud/cloud_info.cpp", "cloud/cloud_server.cpp", "cloud/cloud_share_event.cpp", + "cloud/cloud_sync_finished_event.cpp", "cloud/make_query_event.cpp", "cloud/schema_meta.cpp", "cloud/sharing_center.cpp", diff --git a/services/distributeddataservice/framework/cloud/cloud_sync_finished_event.cpp b/services/distributeddataservice/framework/cloud/cloud_sync_finished_event.cpp new file mode 100644 index 000000000..7640656ec --- /dev/null +++ b/services/distributeddataservice/framework/cloud/cloud_sync_finished_event.cpp @@ -0,0 +1,28 @@ +/* + * 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 "cloud/cloud_sync_finished_event.h" + +namespace OHOS::DistributedData { +CloudSyncFinishedEvent::CloudSyncFinishedEvent(int32_t evtId, const StoreMetaData &storeMetaData) + : CloudEvent(CLOUD_SYNC_FINISHED, storeMetaData.GetStoreInfo()), metaData_(storeMetaData) +{ +} + +StoreMetaData CloudSyncFinishedEvent::GetStoreMeta() const +{ + return metaData_; +} +} \ No newline at end of file diff --git a/services/distributeddataservice/framework/include/cloud/cloud_event.h b/services/distributeddataservice/framework/include/cloud/cloud_event.h index 19837945d..65f3fa0d6 100644 --- a/services/distributeddataservice/framework/include/cloud/cloud_event.h +++ b/services/distributeddataservice/framework/include/cloud/cloud_event.h @@ -31,6 +31,7 @@ public: DATA_CHANGE, CLOUD_SHARE, MAKE_QUERY, + CLOUD_SYNC_FINISHED, CLOUD_BUTT }; diff --git a/services/distributeddataservice/framework/include/cloud/cloud_sync_finished_event.h b/services/distributeddataservice/framework/include/cloud/cloud_sync_finished_event.h new file mode 100644 index 000000000..b8cee5f38 --- /dev/null +++ b/services/distributeddataservice/framework/include/cloud/cloud_sync_finished_event.h @@ -0,0 +1,34 @@ +/* + * 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 OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_CLOUD_CLOUD_SYNC_FINISHED_EVENT_H +#define OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_CLOUD_CLOUD_SYNC_FINISHED_EVENT_H + +#include +#include "cloud_event.h" +#include "metadata/store_meta_data.h" + +namespace OHOS::DistributedData { +class API_EXPORT CloudSyncFinishedEvent : public CloudEvent { +public: + CloudSyncFinishedEvent(int32_t evtId, const StoreMetaData &storeMetaData); + ~CloudSyncFinishedEvent() = default; + StoreMetaData GetStoreMeta() const; + +private: + StoreMetaData metaData_; +}; +} // namespace OHOS::DistributedData +#endif // OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_CLOUD_CLOUD_SYNC_FINISHED_EVENT_H diff --git a/services/distributeddataservice/framework/include/metadata/store_meta_data.h b/services/distributeddataservice/framework/include/metadata/store_meta_data.h index 6540932ef..a20e3913f 100644 --- a/services/distributeddataservice/framework/include/metadata/store_meta_data.h +++ b/services/distributeddataservice/framework/include/metadata/store_meta_data.h @@ -78,6 +78,7 @@ struct API_EXPORT StoreMetaData final : public Serializable { API_EXPORT std::string GetStrategyKey() const; API_EXPORT std::string GetBackupSecretKey() const; API_EXPORT std::string GetStoreAlias() const; + API_EXPORT StoreInfo GetStoreInfo() const; API_EXPORT static std::string GetKey(const std::initializer_list &fields); API_EXPORT static std::string GetPrefix(const std::initializer_list &fields); }; diff --git a/services/distributeddataservice/framework/include/store/general_store.h b/services/distributeddataservice/framework/include/store/general_store.h index df45b56e8..4cd7a24fd 100644 --- a/services/distributeddataservice/framework/include/store/general_store.h +++ b/services/distributeddataservice/framework/include/store/general_store.h @@ -139,7 +139,7 @@ public: virtual int32_t MergeMigratedData(const std::string &tableName, VBuckets &&values) = 0; - virtual std::string GetWaterVersion(const std::string &deviceId) = 0; + virtual std::vector GetWaterVersion(const std::string &deviceId) = 0; }; } // namespace OHOS::DistributedData #endif // OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_STORE_GENERAL_STORE_H diff --git a/services/distributeddataservice/framework/metadata/store_meta_data.cpp b/services/distributeddataservice/framework/metadata/store_meta_data.cpp index 939e95996..b99021de1 100644 --- a/services/distributeddataservice/framework/metadata/store_meta_data.cpp +++ b/services/distributeddataservice/framework/metadata/store_meta_data.cpp @@ -197,5 +197,15 @@ std::string StoreMetaData::GetPrefix(const std::initializer_list &f { return GetKey(fields).append(Constant::KEY_SEPARATOR); } + +StoreInfo StoreMetaData::GetStoreInfo() const +{ + StoreInfo info; + info.instanceId = instanceId; + info.bundleName = bundleName; + info.storeName = storeId; + info.user = atoi(user.c_str()); + return info; +} } // namespace DistributedData } // namespace OHOS diff --git a/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp b/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp index 714faa69f..f461e9575 100644 --- a/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp +++ b/services/distributeddataservice/service/bootstrap/src/bootstrap.cpp @@ -24,6 +24,7 @@ #include "config_factory.h" #include "directory/directory_manager.h" #include "log_print.h" +#include "water_version_manager.h" namespace OHOS { namespace DistributedData { Bootstrap &Bootstrap::GetInstance() @@ -115,6 +116,7 @@ void Bootstrap::LoadCheckers() } checker->AddStaticStore(staticStore); } + WaterVersionManager::GetInstance().Init(); } void Bootstrap::LoadBackup(std::shared_ptr executors) diff --git a/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp b/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp index 15d204f18..9ee0f2b9e 100644 --- a/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp +++ b/services/distributeddataservice/service/kvdb/kvdb_general_store.cpp @@ -16,7 +16,9 @@ #include "kvdb_general_store.h" #include "cloud/schema_meta.h" +#include "cloud/cloud_sync_finished_event.h" #include "crypto_manager.h" +#include "checker/checker_manager.h" #include "device_matrix.h" #include "directory/directory_manager.h" #include "eventcenter/event_center.h" @@ -30,6 +32,7 @@ #include "types.h" #include "user_delegate.h" #include "utils/anonymous.h" +#include "water_version_manager.h" namespace OHOS::DistributedKv { using namespace DistributedData; @@ -115,6 +118,7 @@ KVDBGeneralStore::KVDBGeneralStore(const StoreMetaData &meta) : manager_(meta.ap } delegate_->RegisterObserver({}, DistributedDB::OBSERVER_CHANGES_FOREIGN, &observer_); delegate_->RegisterObserver({}, DistributedDB::OBSERVER_CHANGES_CLOUD, &observer_); + InitWaterVersion(meta); if (meta.isAutoSync) { auto code = DeviceMatrix::GetInstance().GetCode(meta); delegate_->SetRemotePushFinishedNotify([code](const DistributedDB::RemotePushNotifyInfo &info) { @@ -301,7 +305,7 @@ DBStatus KVDBGeneralStore::CloudSync(const Devices &devices, DistributedDB::Sync } else { syncOption.users.push_back(std::to_string(storeInfo_.user)); } - return delegate_->Sync(syncOption, nullptr); + return delegate_->Sync(syncOption, GetDBProcessCB(nullptr)); } int32_t KVDBGeneralStore::Sync(const Devices &devices, GenQuery &query, DetailAsync async, SyncParam &syncParm) @@ -482,10 +486,24 @@ int32_t KVDBGeneralStore::UnregisterDetailProgressObserver() return GenErr::E_OK; } +std::vector KVDBGeneralStore::GetWaterVersion(const std::string &deviceId) +{ + return {}; +} -std::string KVDBGeneralStore::GetWaterVersion(const std::string &deviceId) +void KVDBGeneralStore::InitWaterVersion(const StoreMetaData &meta) { - return ""; + CheckerManager::StoreInfo info = { atoi(meta.user.c_str()), meta.tokenId, meta.bundleName, meta.storeId }; + bool isDynamic = CheckerManager::GetInstance().IsDynamic(info); + bool isStatic = CheckerManager::GetInstance().IsStatic(info); + if (!isDynamic && !isStatic) { + return; + } + // SetGenCloudVersionCallback + callback_ = [meta]() { + auto event = std::make_unique(CloudEvent::CLOUD_SYNC_FINISHED, meta); + EventCenter::GetInstance().PostEvent(std::move(event)); + }; } void KVDBGeneralStore::ObserverProxy::OnChange(DBOrigin origin, const std::string &originalId, DBChangeData &&data) @@ -535,4 +553,38 @@ void KVDBGeneralStore::ObserverProxy::ConvertChangeData(const std::list values.push_back(value); } } + +KVDBGeneralStore::DBProcessCB KVDBGeneralStore::GetDBProcessCB(DetailAsync async) +{ + return [async, callback = callback_](const std::map &processes) { + if (!async && !callback) { + return; + } + DistributedData::GenDetails details; + bool isFinished = false; + for (auto &[id, process] : processes) { + auto &detail = details[id]; + isFinished |= process.process == FINISHED; + detail.progress = process.process; + detail.code = ConvertStatus(process.errCode); + for (auto [key, value] : process.tableProcess) { + auto &table = detail.details[key]; + table.upload.total = value.upLoadInfo.total; + table.upload.success = value.upLoadInfo.successCount; + table.upload.failed = value.upLoadInfo.failCount; + table.upload.untreated = table.upload.total - table.upload.success - table.upload.failed; + table.download.total = value.downLoadInfo.total; + table.download.success = value.downLoadInfo.successCount; + table.download.failed = value.downLoadInfo.failCount; + table.download.untreated = table.download.total - table.download.success - table.download.failed; + } + } + if (async) { + async(details); + } + if (isFinished && callback) { + callback(); + } + }; +} } // namespace OHOS::DistributedKv diff --git a/services/distributeddataservice/service/kvdb/kvdb_general_store.h b/services/distributeddataservice/service/kvdb/kvdb_general_store.h index 5da022a65..e7517c2ca 100644 --- a/services/distributeddataservice/service/kvdb/kvdb_general_store.h +++ b/services/distributeddataservice/service/kvdb/kvdb_general_store.h @@ -70,7 +70,7 @@ public: int32_t Release() override; int32_t BindSnapshots(std::shared_ptr>> bindAssets) override; int32_t MergeMigratedData(const std::string &tableName, VBuckets &&values) override; - std::string GetWaterVersion(const std::string &deviceId) override; + std::vector GetWaterVersion(const std::string &deviceId) override; static DBPassword GetDBPassword(const StoreMetaData &data); static DBOption GetDBOption(const StoreMetaData &data, const DBPassword &password); @@ -84,7 +84,9 @@ private: using DBProcessCB = std::function &processes)>; static GenErr ConvertStatus(DBStatus status); DBSyncCallback GetDBSyncCompleteCB(DetailAsync async); + DBProcessCB GetDBProcessCB(DetailAsync async); DBStatus CloudSync(const Devices &devices, DistributedDB::SyncMode &cloudSyncMode, int64_t wait); + void InitWaterVersion(const StoreMetaData &meta); class ObserverProxy : public DistributedDB::KvStoreObserver { public: using DBOrigin = DistributedDB::Origin; @@ -116,6 +118,7 @@ private: int32_t ref_ = 1; mutable std::shared_mutex rwMutex_; StoreInfo storeInfo_; + std::function callback_; }; } // namespace OHOS::DistributedKv #endif // OHOS_DISTRIBUTED_DATA_DATAMGR_SERVICE_KVDB_GENERAL_STORE_H diff --git a/services/distributeddataservice/service/rdb/rdb_general_store.cpp b/services/distributeddataservice/service/rdb/rdb_general_store.cpp index ee3819417..aa8ed88ef 100644 --- a/services/distributeddataservice/service/rdb/rdb_general_store.cpp +++ b/services/distributeddataservice/service/rdb/rdb_general_store.cpp @@ -811,9 +811,9 @@ VBuckets RdbGeneralStore::QuerySql(const std::string &sql, Values &&args) return ValueProxy::Convert(std::move(changedData)); } -std::string RdbGeneralStore::GetWaterVersion(const std::string &deviceId) +std::vector RdbGeneralStore::GetWaterVersion(const std::string &deviceId) { - return ""; + return {}; } void RdbGeneralStore::ObserverProxy::OnChange(const DBChangedIF &data) diff --git a/services/distributeddataservice/service/rdb/rdb_general_store.h b/services/distributeddataservice/service/rdb/rdb_general_store.h index 10c7a8b27..85ddb9a27 100644 --- a/services/distributeddataservice/service/rdb/rdb_general_store.h +++ b/services/distributeddataservice/service/rdb/rdb_general_store.h @@ -75,7 +75,7 @@ public: int32_t Release() override; int32_t BindSnapshots(std::shared_ptr>> bindAssets) override; int32_t MergeMigratedData(const std::string &tableName, VBuckets&& values) override; - std::string GetWaterVersion(const std::string &deviceId) override; + std::vector GetWaterVersion(const std::string &deviceId) override; private: RdbGeneralStore(const RdbGeneralStore& rdbGeneralStore); diff --git a/services/distributeddataservice/service/waterversion/water_version_manager.cpp b/services/distributeddataservice/service/waterversion/water_version_manager.cpp index 15a55c0dc..9ae39674e 100644 --- a/services/distributeddataservice/service/waterversion/water_version_manager.cpp +++ b/services/distributeddataservice/service/waterversion/water_version_manager.cpp @@ -1,23 +1,25 @@ /* -* 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. + */ #define LOG_TAG "WaterVersionManager" #include "water_version_manager.h" #include "checker/checker_manager.h" +#include "cloud/cloud_sync_finished_event.h" #include "store/auto_cache.h" #include "device_manager_adapter.h" +#include "eventcenter/event_center.h" #include "log_print.h" #include "metadata/meta_data_manager.h" #include "metadata/store_meta_data.h" @@ -59,6 +61,18 @@ void WaterVersionManager::Init() } waterVersions_[meta.type].InitWaterVersion(meta); } + EventCenter::GetInstance().Subscribe(CloudEvent::CLOUD_SYNC_FINISHED, [this](const Event &event) { + auto &cloudSyncFinishedEvent = static_cast(event); + auto storeMeta = cloudSyncFinishedEvent.GetStoreMeta(); + auto store = AutoCache::GetInstance().GetStore(StoreMetaData(storeMeta), {}); + if (store == nullptr) { + return; + } + auto versions = store->GetWaterVersion(""); + for (auto &version : versions) { + SetWaterVersion(storeMeta.bundleName, storeMeta.storeId, version); + } + }); } std::string WaterVersionManager::GenerateWaterVersion(const std::string &bundleName, const std::string &storeName, @@ -143,7 +157,7 @@ bool WaterVersionManager::InitMeta(WaterVersionMetaData &metaData) } auto waterVersion = store->GetWaterVersion(uuid); WaterVersionMetaData meta; - if (waterVersion.empty() || !Serializable::Unmarshall(waterVersion, meta)) { + if (waterVersion.empty() || !Serializable::Unmarshall(*waterVersion.begin(), meta)) { ZLOGE("GetWaterVersion failed! bundleName:%{public}s, storeName:%{public}s, meta:%{public}s", storeMetaData.bundleName.c_str(), storeMetaData.GetStoreAlias().c_str(), meta.ToAnonymousString().c_str()); diff --git a/services/distributeddataservice/service/waterversion/water_version_manager.h b/services/distributeddataservice/service/waterversion/water_version_manager.h index 2bd77eea9..640f31da8 100644 --- a/services/distributeddataservice/service/waterversion/water_version_manager.h +++ b/services/distributeddataservice/service/waterversion/water_version_manager.h @@ -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 OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_WATER_MANAGER_H #define OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_WATER_MANAGER_H #include -- Gitee From 04024ce685ea431604b96947053ff6b244175229 Mon Sep 17 00:00:00 2001 From: htt1997 Date: Tue, 30 Apr 2024 18:06:30 +0800 Subject: [PATCH 7/7] refactor Signed-off-by: htt1997 --- services/distributeddataservice/service/test/BUILD.gn | 1 + .../service/test/fuzztest/cloudservicestub_fuzzer/BUILD.gn | 2 ++ .../service/test/fuzztest/kvdbservicestub_fuzzer/BUILD.gn | 2 ++ .../service/test/fuzztest/objectservicestub_fuzzer/BUILD.gn | 2 ++ .../service/test/fuzztest/rdbservicestub_fuzzer/BUILD.gn | 2 ++ .../service/waterversion/water_version_manager.cpp | 6 +----- 6 files changed, 10 insertions(+), 5 deletions(-) diff --git a/services/distributeddataservice/service/test/BUILD.gn b/services/distributeddataservice/service/test/BUILD.gn index 8d41c1e5e..ffcb0fb93 100644 --- a/services/distributeddataservice/service/test/BUILD.gn +++ b/services/distributeddataservice/service/test/BUILD.gn @@ -249,6 +249,7 @@ ohos_unittest("KVDBGeneralStoreTest") { include_dirs = [ "${data_service_path}/service/common", "${data_service_path}/service/rdb", + "${data_service_path}/service/waterversion", "${relational_store_path}/interfaces/innerapi/clouddata/include", "${relational_store_path}/interfaces/inner_api/rdb/include", "${relational_store_path}/interfaces/inner_api/common_type/include", diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/BUILD.gn index 9f452e1b4..38071fb3f 100644 --- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/BUILD.gn @@ -34,6 +34,7 @@ ohos_fuzztest("CloudServiceStubFuzzTest") { "${data_service_path}/service/object", "${data_service_path}/service/permission/include", "${data_service_path}/service/rdb", + "${data_service_path}/service/waterversion", "${kv_store_common_path}", "${kv_store_path}/frameworks/innerkitsimpl/distributeddatafwk/include", "${kv_store_path}/frameworks/innerkitsimpl/distributeddatasvc/include", @@ -95,6 +96,7 @@ ohos_fuzztest("CloudServiceStubFuzzTest") { "${data_service_path}/service/rdb/rdb_service_impl.cpp", "${data_service_path}/service/rdb/rdb_service_stub.cpp", "${data_service_path}/service/rdb/rdb_watcher.cpp", + "${data_service_path}/service/waterversion/water_version_manager.cpp", "cloudservicestub_fuzzer.cpp", ] diff --git a/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/BUILD.gn index 613e89fb0..468f5bb55 100644 --- a/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/BUILD.gn @@ -33,6 +33,7 @@ ohos_fuzztest("KvdbServiceStubFuzzTest") { "${data_service_path}/service/matrix/include", "${data_service_path}/service/permission/include", "${data_service_path}/service/rdb", + "${data_service_path}/service/waterversion", "${kv_store_common_path}", "${kv_store_path}/frameworks/innerkitsimpl/distributeddatafwk/include", "${kv_store_path}/frameworks/innerkitsimpl/distributeddatasvc/include", @@ -86,6 +87,7 @@ ohos_fuzztest("KvdbServiceStubFuzzTest") { "${data_service_path}/service/permission/src/permit_delegate.cpp", "${data_service_path}/service/rdb/rdb_cloud.cpp", "${data_service_path}/service/rdb/rdb_query.cpp", + "${data_service_path}/service/waterversion/water_version_manager.cpp", "kvdbservicestub_fuzzer.cpp", ] diff --git a/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/BUILD.gn index 4866d1d79..7f35440a5 100644 --- a/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/BUILD.gn @@ -29,6 +29,7 @@ ohos_fuzztest("ObjectServiceStubFuzzTest") { "${data_service_path}/service/config/include", "${data_service_path}/service/crypto/include", "${data_service_path}/service/object", + "${data_service_path}/service/waterversion", "${kv_store_common_path}", "${kv_store_path}/frameworks/innerkitsimpl/distributeddatafwk/include", "${kv_store_path}/frameworks/innerkitsimpl/distributeddatasvc/include", @@ -77,6 +78,7 @@ ohos_fuzztest("ObjectServiceStubFuzzTest") { "${data_service_path}/service/object/object_service_stub.cpp", "${data_service_path}/service/object/object_snapshot.cpp", "${data_service_path}/service/object/object_types_utils.cpp", + "${data_service_path}/service/waterversion/water_version_manager.cpp", "objectservicestub_fuzzer.cpp", ] diff --git a/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/BUILD.gn b/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/BUILD.gn index fc4a309ab..8482f6063 100644 --- a/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/BUILD.gn +++ b/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/BUILD.gn @@ -35,6 +35,7 @@ ohos_fuzztest("RdbServiceStubFuzzTest") { "${data_service_path}/service/object", "${data_service_path}/service/permission/include", "${data_service_path}/service/rdb", + "${data_service_path}/service/waterversion", "${kv_store_common_path}", "${kv_store_path}/frameworks/innerkitsimpl/distributeddatafwk/include", "${kv_store_path}/frameworks/innerkitsimpl/distributeddatasvc/include", @@ -89,6 +90,7 @@ ohos_fuzztest("RdbServiceStubFuzzTest") { "${data_service_path}/service/rdb/rdb_service_impl.cpp", "${data_service_path}/service/rdb/rdb_service_stub.cpp", "${data_service_path}/service/rdb/rdb_watcher.cpp", + "${data_service_path}/service/waterversion/water_version_manager.cpp", "rdbservicestub_fuzzer.cpp", ] diff --git a/services/distributeddataservice/service/waterversion/water_version_manager.cpp b/services/distributeddataservice/service/waterversion/water_version_manager.cpp index 9ae39674e..c2547e766 100644 --- a/services/distributeddataservice/service/waterversion/water_version_manager.cpp +++ b/services/distributeddataservice/service/waterversion/water_version_manager.cpp @@ -118,10 +118,6 @@ bool WaterVersionManager::SetWaterVersion(const std::string &bundleName, const s metaData.ToAnonymousString().c_str(), bundleName.c_str(), Anonymous::Change(storeName).c_str()); return false; } - - std::string key = Merge(bundleName, storeName); - ZLOGE("error key. deviceId:%{public}s, bundleName:%{public}s, storeName:%{public}s", - Anonymous::Change(metaData.deviceId).c_str(), bundleName.c_str(), Anonymous::Change(storeName).c_str()); return waterVersions_[metaData.type].SetWaterVersion(Merge(bundleName, storeName), metaData); } @@ -381,7 +377,7 @@ bool WaterVersionManager::WaterVersion::SetWaterVersion(const std::string &key, const WaterVersionMetaData &metaData) { if (std::find(keys_.begin(), keys_.end(), key) == keys_.end()) { - ZLOGE("invalid key:%{public}s", metaData.ToAnonymousString().c_str()); + ZLOGE("invalid key. meta:%{public}s", metaData.ToAnonymousString().c_str()); return false; } WaterVersionMetaData oldMeta; -- Gitee