diff --git a/services/distributeddataservice/adapter/communicator/src/device_manager_adapter.cpp b/services/distributeddataservice/adapter/communicator/src/device_manager_adapter.cpp index ea4915cf92b30b23b56078c8ecced2ade3fd2c5a..5ad57fb78b6746f00122c349e31d23636b2c3833 100644 --- a/services/distributeddataservice/adapter/communicator/src/device_manager_adapter.cpp +++ b/services/distributeddataservice/adapter/communicator/src/device_manager_adapter.cpp @@ -573,6 +573,19 @@ std::vector DeviceManagerAdapter::ToUUID(const std::vector DeviceManagerAdapter::ToUDID(const std::vector &devices) +{ + std::vector udids; + for (auto &device : devices) { + auto udid = DeviceManagerAdapter::GetInstance().ToUDID(device); + if (udid.empty()) { + continue; + } + udids.push_back(std::move(udid)); + } + return udids; +} + std::vector DeviceManagerAdapter::ToUUID(std::vector devices) { std::vector uuids; @@ -585,6 +598,18 @@ std::vector DeviceManagerAdapter::ToUUID(std::vector de return uuids; } +std::vector DeviceManagerAdapter::ToUDID(std::vector devices) +{ + std::vector udids; + for (auto &device : devices) { + if (device.udid.empty()) { + continue; + } + udids.push_back(std::move(device.udid)); + } + return udids; +} + std::string DeviceManagerAdapter::ToNetworkID(const std::string &id) { return GetDeviceInfoFromCache(id).networkId; diff --git a/services/distributeddataservice/adapter/communicator/test/unittest/device_manager_adapter_test.cpp b/services/distributeddataservice/adapter/communicator/test/unittest/device_manager_adapter_test.cpp index f08d3153b29341fecb6934cd3cd029a1e53cc6bb..855f2a5d4c125eaf0a12aef49a1142e7e9f6a514 100644 --- a/services/distributeddataservice/adapter/communicator/test/unittest/device_manager_adapter_test.cpp +++ b/services/distributeddataservice/adapter/communicator/test/unittest/device_manager_adapter_test.cpp @@ -311,6 +311,29 @@ HWTEST_F(DeviceManagerAdapterTest, DeviceIdsToUUID, TestSize.Level0) } } +/** +* @tc.name: DeviceIdToUDID +* @tc.desc: transfer deviceIds to udid +* @tc.type: FUNC +* @tc.require: +* @tc.author: zd + */ +HWTEST_F(DeviceManagerAdapterTest, DeviceIdsToUDID, TestSize.Level0) +{ + std::vector devices; + devices.emplace_back(EMPTY_DEVICE_ID); + devices.emplace_back(INVALID_DEVICE_ID); + auto dvInfo = DeviceManagerAdapter::GetInstance().GetLocalDevice(); + devices.emplace_back(dvInfo.uuid); + devices.emplace_back(dvInfo.udid); + devices.emplace_back(dvInfo.networkId); + auto udids = DeviceManagerAdapter::GetInstance().ToUDID(devices); + EXPECT_EQ(udids.size(), LOCAL_DEVICE_ID_NUM); + for (const auto &udid : udids) { + EXPECT_EQ(udid, dvInfo.udid); + } +} + /** * @tc.name: DeviceIdToUUID * @tc.desc: transfer deviceIds to uuid @@ -333,6 +356,28 @@ HWTEST_F(DeviceManagerAdapterTest, DeviceIdToUUID, TestSize.Level0) EXPECT_EQ(uuids[1], dvInfo.uuid); } +/** +* @tc.name: DeviceInfosToUUID +* @tc.desc: transfer deviceIds to udid +* @tc.type: FUNC +* @tc.require: +* @tc.author: zd + */ +HWTEST_F(DeviceManagerAdapterTest, DeviceInfosToUUID, TestSize.Level0) +{ + std::vector devices; + DeviceInfo dvInfo; + devices.emplace_back(dvInfo); + dvInfo.udid = INVALID_DEVICE_ID; + devices.emplace_back(dvInfo); + dvInfo = DeviceManagerAdapter::GetInstance().GetLocalDevice(); + devices.emplace_back(dvInfo); + auto udids = DeviceManagerAdapter::GetInstance().ToUDID(devices); + EXPECT_EQ(udids.size(), LOCAL_UUID_NUM); + EXPECT_EQ(udids[0], INVALID_DEVICE_ID); + EXPECT_EQ(udids[1], dvInfo.udid); +} + /** * @tc.name: DeviceIdToNetworkId * @tc.desc: transfer deviceId to networkId, the deviceId is invalid diff --git a/services/distributeddataservice/adapter/include/communicator/device_manager_adapter.h b/services/distributeddataservice/adapter/include/communicator/device_manager_adapter.h index 575a2f3931a8b3435f3492cec42cc0823803810d..9a9bc67b9f87e332f3f23f0be62e5e500adb29e3 100644 --- a/services/distributeddataservice/adapter/include/communicator/device_manager_adapter.h +++ b/services/distributeddataservice/adapter/include/communicator/device_manager_adapter.h @@ -67,7 +67,9 @@ public: std::string ToUUID(const std::string &id); std::string ToUDID(const std::string &id); static std::vector ToUUID(const std::vector &devices); + static std::vector ToUDID(const std::vector &devices); static std::vector ToUUID(std::vector devices); + static std::vector ToUDID(std::vector devices); std::string ToNetworkID(const std::string &id); void NotifyReadyEvent(const std::string &uuid); int32_t GetAuthType(const std::string& id); diff --git a/services/distributeddataservice/app/src/kvstore_data_service.cpp b/services/distributeddataservice/app/src/kvstore_data_service.cpp index 51af0c61e09fed7a55bceae2b34aa11a97ed40ce..f7a34cad01f4634c4fd14f7ca655c276fd204794 100644 --- a/services/distributeddataservice/app/src/kvstore_data_service.cpp +++ b/services/distributeddataservice/app/src/kvstore_data_service.cpp @@ -909,7 +909,7 @@ void KvStoreDataService::AccountEventChanged(const AccountEventInfo &eventInfo) g_kvStoreAccountEventStatus = 1; // delete all kvstore meta belong to this user std::vector metaData; - MetaDataManager::GetInstance().LoadMeta(StoreMetaData::GetPrefix({""}), metaData, true); + MetaDataManager::GetInstance().LoadMeta(StoreMetaData::GetPrefix({}), metaData, true); for (const auto &meta : metaData) { if (meta.user != eventInfo.userId) { continue; diff --git a/services/distributeddataservice/framework/device_sync_app/device_sync_app_manager.cpp b/services/distributeddataservice/framework/device_sync_app/device_sync_app_manager.cpp index e20ee46ef181dd261371ee36788e70cd6f83cc79..b7a2e671a03e4273ae856765356dce0b35af79aa 100644 --- a/services/distributeddataservice/framework/device_sync_app/device_sync_app_manager.cpp +++ b/services/distributeddataservice/framework/device_sync_app/device_sync_app_manager.cpp @@ -33,7 +33,7 @@ void DeviceSyncAppManager::Initialize(const std::vector &lists) } } -bool DeviceSyncAppManager::Check(const WhiteList &whiteList) +bool DeviceSyncAppManager::CheckVersion(const WhiteList &whiteList) { for (const auto &info : whiteLists_) { if (info.appId == whiteList.appId && (info.bundleName == whiteList.bundleName) && @@ -43,5 +43,13 @@ bool DeviceSyncAppManager::Check(const WhiteList &whiteList) } return false; } - +bool DeviceSyncAppManager::CheckBundleName(const std::string &bundleName, const std::string &appId) +{ + for (const auto &info : whiteLists_) { + if (info.appId == appId && (info.bundleName == bundleName)) { + return true; + } + } + return false; +} } // namespace OHOS::DistributedData \ No newline at end of file diff --git a/services/distributeddataservice/framework/include/device_sync_app/device_sync_app_manager.h b/services/distributeddataservice/framework/include/device_sync_app/device_sync_app_manager.h index 664883bce41c938e7644226cef7392cd7daf0a88..d3116e3188eab420b7ae1e039f6c6e330bb358fa 100644 --- a/services/distributeddataservice/framework/include/device_sync_app/device_sync_app_manager.h +++ b/services/distributeddataservice/framework/include/device_sync_app/device_sync_app_manager.h @@ -29,7 +29,8 @@ public: }; API_EXPORT static DeviceSyncAppManager &GetInstance(); API_EXPORT void Initialize(const std::vector &lists); - API_EXPORT bool Check(const WhiteList &whiteList); + API_EXPORT bool CheckVersion(const WhiteList &whiteList); + API_EXPORT bool CheckBundleName(const std::string &bundleName, const std::string &appId); private: DeviceSyncAppManager(); diff --git a/services/distributeddataservice/framework/include/metadata/store_meta_data.h b/services/distributeddataservice/framework/include/metadata/store_meta_data.h index 201fccc012261462b78233df92c347abfb934425..a72bbd19a7cf3c21ee803d12075939fb8b75f4d2 100644 --- a/services/distributeddataservice/framework/include/metadata/store_meta_data.h +++ b/services/distributeddataservice/framework/include/metadata/store_meta_data.h @@ -91,6 +91,7 @@ struct API_EXPORT StoreMetaData : public Serializable { API_EXPORT virtual std::string GetStrategyKey() const; API_EXPORT virtual std::string GetBackupSecretKey() const; API_EXPORT virtual std::string GetAutoLaunchKey() const; + API_EXPORT virtual std::string GetAutoSyncDeviceKey() const; API_EXPORT virtual std::string GetDebugInfoKey() const; API_EXPORT virtual std::string GetDebugInfoKeyWithoutPath() const; API_EXPORT virtual std::string GetDfxInfoKey() const; diff --git a/services/distributeddataservice/framework/include/metadata/store_meta_data_local.h b/services/distributeddataservice/framework/include/metadata/store_meta_data_local.h old mode 100755 new mode 100644 index 717b495f997670d39ac5fce9a7455443af1dfcb2..c3242140bdd5081ed6b4cc58cdd2e12a838dae36 --- a/services/distributeddataservice/framework/include/metadata/store_meta_data_local.h +++ b/services/distributeddataservice/framework/include/metadata/store_meta_data_local.h @@ -81,5 +81,17 @@ struct API_EXPORT StoreDfxInfo final : public Serializable { private: static constexpr const char *KEY_PREFIX = "StoreDfxInfo"; }; + +struct API_EXPORT AutoSyncDevicesInfo final : public Serializable { + std::vector udids {}; + API_EXPORT AutoSyncDevicesInfo() = default; + API_EXPORT ~AutoSyncDevicesInfo() = default; + API_EXPORT static std::string GetKey(const std::initializer_list &fields); + bool Marshal(Serializable::json &node) const override; + bool Unmarshal(const Serializable::json &node) override; + +private: + static constexpr const char *KEY_PREFIX = "AutoSyncDevice"; +}; } // namespace OHOS::DistributedData #endif // OHOS_DISTRIBUTED_DATA_SERVICES_FRAMEWORK_METADATA_STORE_META_DATA_LOCAL_H diff --git a/services/distributeddataservice/framework/metadata/store_meta_data.cpp b/services/distributeddataservice/framework/metadata/store_meta_data.cpp index 3dba8c533027f644a21d44a3130f00e9bc748126..6255d384e05cf8a14ac80c28f1e7b349422c2bba 100644 --- a/services/distributeddataservice/framework/metadata/store_meta_data.cpp +++ b/services/distributeddataservice/framework/metadata/store_meta_data.cpp @@ -196,6 +196,11 @@ std::string StoreMetaData::GetAutoLaunchKey() const return AutoLaunchMetaData::GetPrefix({ deviceId, user, "default", bundleName, storeId }); } +std::string StoreMetaData::GetAutoSyncDeviceKey() const +{ + return AutoSyncDevicesInfo::GetKey({ deviceId, user, "default", bundleName, storeId, dataDir }); +} + std::string StoreMetaData::GetDebugInfoKey() const { return StoreDebugInfo::GetPrefix( diff --git a/services/distributeddataservice/framework/metadata/store_meta_data_local.cpp b/services/distributeddataservice/framework/metadata/store_meta_data_local.cpp old mode 100755 new mode 100644 index 19aea85c52cf3a127368444f31e4c18b9974c7d9..8fa74a287c1e5790e139b399ad2af2469f0d1717 --- a/services/distributeddataservice/framework/metadata/store_meta_data_local.cpp +++ b/services/distributeddataservice/framework/metadata/store_meta_data_local.cpp @@ -155,5 +155,20 @@ bool StoreDfxInfo::Unmarshal(const json &node) GetValue(node, GET_NAME(lastOpenTime), lastOpenTime); return true; } +std::string AutoSyncDevicesInfo::GetKey(const std::initializer_list &fields) +{ + return Constant::Join(AutoSyncDevicesInfo::KEY_PREFIX, Constant::KEY_SEPARATOR, fields); +} +bool AutoSyncDevicesInfo::Marshal(json &node) const +{ + SetValue(node[GET_NAME(udids)], udids); + return true; +} + +bool AutoSyncDevicesInfo::Unmarshal(const json &node) +{ + GetValue(node, GET_NAME(udids), udids); + return true; +} } // namespace DistributedData } // namespace OHOS diff --git a/services/distributeddataservice/framework/test/device_sync_app_manager_test.cpp b/services/distributeddataservice/framework/test/device_sync_app_manager_test.cpp index 6ae441b9f46f540bfcf026c3265783a4347eec9f..a4f375f60e40d3b8a304d1556d617e4341ec18ac 100644 --- a/services/distributeddataservice/framework/test/device_sync_app_manager_test.cpp +++ b/services/distributeddataservice/framework/test/device_sync_app_manager_test.cpp @@ -44,7 +44,7 @@ public: HWTEST_F(DeviceSyncAppManagerTest, Check001, TestSize.Level1) { DeviceSyncAppManager::WhiteList whiteList = {"appId1", "bundleName1", 1}; - bool result = DeviceSyncAppManager::GetInstance().Check(whiteList); + bool result = DeviceSyncAppManager::GetInstance().CheckVersion(whiteList); EXPECT_TRUE(result); } @@ -56,7 +56,7 @@ HWTEST_F(DeviceSyncAppManagerTest, Check001, TestSize.Level1) HWTEST_F(DeviceSyncAppManagerTest, Check002, TestSize.Level1) { DeviceSyncAppManager::WhiteList testList = {"appId2", "bundleName1", 1}; - bool result = DeviceSyncAppManager::GetInstance().Check(testList); + bool result = DeviceSyncAppManager::GetInstance().CheckVersion(testList); EXPECT_FALSE(result); } @@ -68,7 +68,7 @@ HWTEST_F(DeviceSyncAppManagerTest, Check002, TestSize.Level1) HWTEST_F(DeviceSyncAppManagerTest, Check003, TestSize.Level1) { DeviceSyncAppManager::WhiteList testList = {"appId1", "bundleName2", 1}; - bool result = DeviceSyncAppManager::GetInstance().Check(testList); + bool result = DeviceSyncAppManager::GetInstance().CheckVersion(testList); EXPECT_FALSE(result); } @@ -80,7 +80,7 @@ HWTEST_F(DeviceSyncAppManagerTest, Check003, TestSize.Level1) HWTEST_F(DeviceSyncAppManagerTest, Check004, TestSize.Level1) { DeviceSyncAppManager::WhiteList testList = {"appId1", "bundleName1", 2}; - bool result = DeviceSyncAppManager::GetInstance().Check(testList); + bool result = DeviceSyncAppManager::GetInstance().CheckVersion(testList); EXPECT_FALSE(result); } @@ -92,7 +92,38 @@ HWTEST_F(DeviceSyncAppManagerTest, Check004, TestSize.Level1) HWTEST_F(DeviceSyncAppManagerTest, Check005, TestSize.Level1) { DeviceSyncAppManager::WhiteList whiteList = {"appId4", "bundleName4", 4}; - bool result = DeviceSyncAppManager::GetInstance().Check(whiteList); + bool result = DeviceSyncAppManager::GetInstance().CheckVersion(whiteList); EXPECT_FALSE(result); } + +/** +* @tc.name: Check006 +* @tc.desc: Checks that the given WhiteList object does not exist in whiteLists_ list. +* @tc.type: FUNC +*/ +HWTEST_F(DeviceSyncAppManagerTest, Check006, TestSize.Level1) +{ + bool result = DeviceSyncAppManager::GetInstance().CheckBundleName("bundleName4", "appId4"); + EXPECT_FALSE(result); +} +/** +* @tc.name: Check007 +* @tc.desc: Check that the given bundleName object does not match. +* @tc.type: FUNC +*/ +HWTEST_F(DeviceSyncAppManagerTest, Check007, TestSize.Level1) +{ + bool result = DeviceSyncAppManager::GetInstance().CheckBundleName("bundleName2", "appId1"); + EXPECT_FALSE(result); +} +/** +* @tc.name: Check008 +* @tc.desc: Checks that the given WhiteList object exists in whiteLists_ list. +* @tc.type: FUNC +*/ +HWTEST_F(DeviceSyncAppManagerTest, Check008, TestSize.Level1) +{ + bool result = DeviceSyncAppManager::GetInstance().CheckBundleName("bundleName1", "appId1"); + EXPECT_TRUE(result); +} } // namespace OHOS::Test \ No newline at end of file diff --git a/services/distributeddataservice/service/rdb/rdb_general_store.cpp b/services/distributeddataservice/service/rdb/rdb_general_store.cpp index d6b43d5beeecb7ad9944735e2aebfe4885c17e1f..cd4745a7db9d3bd9f89acd648ec7e42251991c38 100644 --- a/services/distributeddataservice/service/rdb/rdb_general_store.cpp +++ b/services/distributeddataservice/service/rdb/rdb_general_store.cpp @@ -961,7 +961,7 @@ int32_t RdbGeneralStore::SetDistributedTables(const std::vector &ta } auto [exist, database] = GetDistributedSchema(observer_.meta_); if (exist && type == DistributedTableType::DISTRIBUTED_DEVICE) { - auto force = DeviceSyncAppManager::GetInstance().Check( + auto force = DeviceSyncAppManager::GetInstance().CheckVersion( {observer_.meta_.appId, observer_.meta_.bundleName, database.version}); delegate_->SetDistributedSchema(GetGaussDistributedSchema(database), force); } diff --git a/services/distributeddataservice/service/rdb/rdb_query.cpp b/services/distributeddataservice/service/rdb/rdb_query.cpp index 994a98a458a6520f08113e88e5b85259630d29b8..ec716bbcc1eee2b2f4e43f4691ee2fed7e68a81f 100644 --- a/services/distributeddataservice/service/rdb/rdb_query.cpp +++ b/services/distributeddataservice/service/rdb/rdb_query.cpp @@ -70,9 +70,9 @@ void RdbQuery::MakeQuery(const PredicatesMemo &predicates) tables_ = predicates.tables_; } -void RdbQuery::MakeQuery(const std::string &table) +void RdbQuery::MakeDeviceQuery(const std::vector &tables) { - query_ = DistributedDB::Query::Select(table); + query_ = DistributedDB::Query::Select().FromTable(tables); } void RdbQuery::MakeCloudQuery(const PredicatesMemo& predicates) diff --git a/services/distributeddataservice/service/rdb/rdb_query.h b/services/distributeddataservice/service/rdb/rdb_query.h index 94d9460f233deea470bf3cec07a79a668d75d3a5..cf80b032a9210ba56acb9a4ba1d3e1f33b5943e1 100644 --- a/services/distributeddataservice/service/rdb/rdb_query.h +++ b/services/distributeddataservice/service/rdb/rdb_query.h @@ -41,7 +41,7 @@ public: bool IsRemoteQuery(); bool IsPriority(); void MakeQuery(const PredicatesMemo &predicates); - void MakeQuery(const std::string &table); + void MakeDeviceQuery(const std::vector &tables); void MakeRemoteQuery(const std::string &devices, const std::string &sql, DistributedData::Values &&args); void MakeCloudQuery(const PredicatesMemo &predicates); diff --git a/services/distributeddataservice/service/rdb/rdb_service_impl.cpp b/services/distributeddataservice/service/rdb/rdb_service_impl.cpp index 43c0c7cfb7742388bdae43d9884de443089ea025..2a4ec5713372a185027869f7759cddc28241a8bf 100644 --- a/services/distributeddataservice/service/rdb/rdb_service_impl.cpp +++ b/services/distributeddataservice/service/rdb/rdb_service_impl.cpp @@ -28,6 +28,7 @@ #include "cloud/schema_meta.h" #include "communicator/device_manager_adapter.h" #include "device_matrix.h" +#include "device_sync_app/device_sync_app_manager.h" #include "directory/directory_manager.h" #include "dump/dump_manager.h" #include "eventcenter/event_center.h" @@ -60,7 +61,6 @@ using OHOS::DistributedData::Anonymous; using OHOS::DistributedData::CheckerManager; using OHOS::DistributedData::MetaDataManager; using OHOS::DistributedData::StoreMetaData; -using OHOS::DistributedData::AccountDelegate; using namespace OHOS::DistributedData; using namespace OHOS::Security::AccessToken; using DistributedDB::RelationalStoreManager; @@ -71,6 +71,7 @@ using system_clock = std::chrono::system_clock; constexpr uint32_t ITERATE_TIMES = 10000; constexpr uint32_t ALLOW_ONLINE_AUTO_SYNC = 8; +constexpr uint32_t ALLOW_AUTO_SYNC_DEVICE = 10; constexpr int32_t VALID_PARAM_LENGTH = 2; const size_t KEY_COUNT = 2; namespace OHOS::DistributedRdb { @@ -291,8 +292,9 @@ void RdbServiceImpl::UpdateMeta(const StoreMetaData &meta, const StoreMetaData & syncMeta.isEncrypt, meta.isEncrypt, syncMeta.area, meta.area); MetaDataManager::GetInstance().SaveMeta(meta.GetKeyWithoutPath(), localMeta); } + bool isAutoSync = DeviceSyncAppManager::GetInstance().CheckBundleName(meta.bundleName, meta.appId); Database dataBase; - if (RdbSchemaConfig::GetDistributedSchema(localMeta, dataBase) && !dataBase.name.empty() && + if (isAutoSync && RdbSchemaConfig::GetDistributedSchema(localMeta, dataBase) && !dataBase.name.empty() && !dataBase.bundleName.empty()) { MetaDataManager::GetInstance().SaveMeta(dataBase.GetKey(), dataBase, true); store->SetConfig({false, GeneralStore::DistributedTableMode::COLLABORATION}); @@ -466,10 +468,48 @@ int32_t RdbServiceImpl::Sync(const RdbSyncerParam ¶m, const Option &option, return DoSync(param, option, predicates, async); } +void RdbServiceImpl::SaveAutoSyncDeviceId(const StoreMetaData &meta, const PredicatesMemo &predicates) +{ + DistributedData::AutoSyncDevicesInfo deviceInfos; + std::vector devices = DmAdapter::ToUDID(predicates.devices_); + if (devices.empty()) { + ZLOGE("There is no deviceId in predicates"); + return; + } + if(!MetaDataManager::GetInstance().LoadMeta(meta.GetAutoSyncDeviceKey(), deviceInfos, true)){ + deviceInfos.udids = std::move(devices); + MetaDataManager::GetInstance().SaveMeta(meta.GetAutoSyncDeviceKey(), deviceInfos, true); + return; + } + for (auto &device : devices) { + auto iter = std::find(deviceInfos.udids.begin(), deviceInfos.udids.end(), device); + if (iter != deviceInfos.udids.end() && deviceInfos.udids.size() == 1){ + continue; + } + if (iter != deviceInfos.udids.end()) { + std::swap(*iter, deviceInfos.udids.back()); + } else { + deviceInfos.udids.push_back(device); + } + } + if (deviceInfos.udids.size() > ALLOW_AUTO_SYNC_DEVICE) { + auto index = deviceInfos.udids.size() - ALLOW_AUTO_SYNC_DEVICE; + deviceInfos.udids.erase(deviceInfos.udids.begin(), deviceInfos.udids.begin() + index - 1); + } + MetaDataManager::GetInstance().SaveMeta(meta.GetAutoSyncDeviceKey(), deviceInfos, true); +} + int RdbServiceImpl::DoSync(const RdbSyncerParam ¶m, const RdbService::Option &option, const PredicatesMemo &predicates, const AsyncDetail &async) { StoreMetaData meta = GetStoreMetaData(param); + if(meta.instanceId != 0) { + return RDB_ERROR; + } + bool isAutoSync = DeviceSyncAppManager::GetInstance().CheckBundleName(meta.bundleName, meta.appId); + if (isAutoSync) { + SaveAutoSyncDeviceId(meta, predicates); + } auto store = GetStore(meta); if (store == nullptr) { return RDB_ERROR; @@ -1196,9 +1236,22 @@ std::vector RdbServiceImpl::GetReuseDevice(const std::vector &devices, const Database &dataBase, std::vector tables) + const std::vector &devices, const StoreMetaData &storeMetaData, std::vector tables) { - StoreMetaData storeMetaData = GetStoreMetaData(dataBase); + if(storeMetaData.instanceId != 0) { + return RDB_ERROR; + } + std::vector isSyncDevices; + std::vector deviceIds = DmAdapter::ToUDID(DmAdapter::GetInstance().GetRemoteDevices()); + for(auto &device : devices){ + if(std::find(deviceIds.begin(), deviceIds.end(), device) != deviceIds.end()){ + isSyncDevices.push_back(device); + } + } + if (isSyncDevices.empty()) { + ZLOGE("Designated syncdevice not in trustdevicelist.storeId:%{public}s", storeMetaData.GetStoreAlias().c_str()); + return RDB_ERROR; + } auto store = GetStore(storeMetaData); if (store == nullptr) { ZLOGE("autosync store null, storeId:%{public}s", storeMetaData.GetStoreAlias().c_str()); @@ -1210,44 +1263,60 @@ int RdbServiceImpl::DoAutoSync( } SyncParam syncParam = { 0, 0 }; DetailAsync async; - for (auto &table : tables) { - executors_->Execute([this, table, store, syncParam, async, devices, storeMetaData]() { - RdbQuery rdbQuery; - rdbQuery.MakeQuery(table); - std::vector onDevices = GetReuseDevice(devices, storeMetaData); - if (onDevices.empty()) { - ZLOGE("autosync ondevices null, storeId:%{public}s", storeMetaData.GetStoreAlias().c_str()); - return; - } - auto complete = [this, rdbQuery, store, syncParam, async]( - const auto &results) mutable { - auto ret = ProcessResult(results); - store->Sync(ret.first, rdbQuery, async, syncParam); - }; - if (IsNeedMetaSync(storeMetaData, onDevices)) { - MetaDataManager::GetInstance().Sync(onDevices, complete); - return; - } - (void)store->Sync(onDevices, rdbQuery, async, syncParam).first; + executors_->Execute([this, tables, store, syncParam, async, isSyncDevices, storeMetaData]() { + RdbQuery rdbQuery; + rdbQuery.MakeDeviceQuery(tables); + std::vector onDevices = GetReuseDevice(isSyncDevices, storeMetaData); + if (onDevices.empty()) { + ZLOGE("autosync device null, storeId:%{public}s", storeMetaData.GetStoreAlias().c_str()); return; - }); - } + } + auto complete = [this, rdbQuery, store, syncParam, async](const auto &results) mutable { + auto ret = ProcessResult(results); + store->Sync(ret.first, rdbQuery, async, syncParam); + }; + if (IsNeedMetaSync(storeMetaData, onDevices)) { + MetaDataManager::GetInstance().Sync(onDevices, complete); + return; + } + (void)store->Sync(onDevices, rdbQuery, async, syncParam).first; + return; + }); return RDB_OK; } int RdbServiceImpl::DoOnlineSync(const std::vector &devices, const Database &dataBase) { + if (devices.empty()) { + return RDB_ERROR; + } std::vector tableNames; for (auto &table : dataBase.tables) { if (!table.deviceSyncFields.empty()) { tableNames.push_back(table.name); } } - return DoAutoSync(devices, dataBase, tableNames); + StoreMetaData storeMetaData = GetStoreMetaData(dataBase); + DistributedData::AutoSyncDevicesInfo deviceInfos; + if(!MetaDataManager::GetInstance().LoadMeta(storeMetaData.GetAutoSyncDeviceKey(), deviceInfos, true)){ + return RDB_ERROR; + } + std::vector deviceIds = DmAdapter::ToUDID(devices); + if(deviceIds.empty()){ + return RDB_ERROR; + } + if (deviceInfos.udids.empty() || + std::find(deviceInfos.udids.begin(), deviceInfos.udids.end(), deviceIds[0]) == deviceInfos.udids.end()) { + return RDB_ERROR; + } + return DoAutoSync(devices, storeMetaData, tableNames); } int32_t RdbServiceImpl::OnReady(const std::string &device) { + if(device.empty()){ + return 0; + } int index = ALLOW_ONLINE_AUTO_SYNC; Database dataBase; std::string prefix = dataBase.GetPrefix({}); @@ -1414,13 +1483,19 @@ int RdbServiceImpl::DoDataChangeSync(const StoreInfo &storeInfo, const RdbChange tableNames.push_back(key); } } - if (MetaDataManager::GetInstance().LoadMeta(dataBase.GetKey(), dataBase, true)) { - std::vector devices = DmAdapter::ToUUID(DmAdapter::GetInstance().GetRemoteDevices()); - if ((dataBase.autoSyncType == AutoSyncType::SYNC_ON_CHANGE || - dataBase.autoSyncType == AutoSyncType::SYNC_ON_CHANGE_READY) && - !devices.empty()) { - return DoAutoSync(devices, dataBase, tableNames); - } + if (!MetaDataManager::GetInstance().LoadMeta(dataBase.GetKey(), dataBase, true)) { + return RDB_OK; + } + StoreMetaData storeMetaData = GetStoreMetaData(dataBase); + DistributedData::AutoSyncDevicesInfo deviceInfos; + if (!MetaDataManager::GetInstance().LoadMeta(storeMetaData.GetAutoSyncDeviceKey(), deviceInfos, true) || + deviceInfos.udids.empty()) { + ZLOGE("There is no autoSyncDevice, store:%{public}s.", Anonymous::Change(storeInfo.storeName).c_str()); + return RDB_ERROR; + } + if ((dataBase.autoSyncType == AutoSyncType::SYNC_ON_CHANGE || + dataBase.autoSyncType == AutoSyncType::SYNC_ON_CHANGE_READY)) { + return DoAutoSync(deviceInfos.udids, storeMetaData, tableNames); } return RDB_OK; } diff --git a/services/distributeddataservice/service/rdb/rdb_service_impl.h b/services/distributeddataservice/service/rdb/rdb_service_impl.h index b7fe3c03c401819504d293ea15f227ef7ceed66d..fe36b10ee1628f45b0fa9261fd3a23ac32eb3a11 100644 --- a/services/distributeddataservice/service/rdb/rdb_service_impl.h +++ b/services/distributeddataservice/service/rdb/rdb_service_impl.h @@ -178,12 +178,14 @@ private: const AsyncDetail &async); void DoCompensateSync(const DistributedData::BindEvent& event); + + void SaveAutoSyncDeviceId(const StoreMetaData &meta, const PredicatesMemo &predicates); int DoSync(const RdbSyncerParam ¶m, const Option &option, const PredicatesMemo &predicates, const AsyncDetail &async); int DoAutoSync( - const std::vector &devices, const Database &dataBase, std::vector tableNames); + const std::vector &devices, const StoreMetaData &storeMetaData, std::vector tables); std::vector GetReuseDevice(const std::vector &devices, const StoreMetaData &metaData); int DoOnlineSync(const std::vector &devices, const Database &dataBase); diff --git a/services/distributeddataservice/service/test/rdb_service_impl_test.cpp b/services/distributeddataservice/service/test/rdb_service_impl_test.cpp index abe2488366efda20b6e61484c63261d102a69a26..2524b7d86eb08fd8d869f8ff932e92f3ac9c76aa 100644 --- a/services/distributeddataservice/service/test/rdb_service_impl_test.cpp +++ b/services/distributeddataservice/service/test/rdb_service_impl_test.cpp @@ -639,10 +639,10 @@ HWTEST_F(RdbServiceImplTest, DoAutoSync001, TestSize.Level0) { RdbServiceImpl service; std::vector devices = {"device1"}; - DistributedData::Database dataBase; + StoreMetaData meta; std::vector tables = {"table1"}; - auto result = service.DoAutoSync(devices, dataBase, tables); + auto result = service.DoAutoSync(devices, meta, tables); EXPECT_EQ(result, RDB_ERROR); } @@ -661,13 +661,14 @@ HWTEST_F(RdbServiceImplTest, DoAutoSync002, TestSize.Level0) metaMapping.devicePath = "path1"; EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true); RdbServiceImpl service; + StoreMetaData meta; std::vector devices = {"device1"}; DistributedData::Database dataBase; std::vector tables = {"table1"}; - dataBase.bundleName = "bundleName"; - dataBase.name = "storeName"; - dataBase.user = "100"; - auto result = service.DoAutoSync(devices, dataBase, tables); + meta.bundleName = "bundleName"; + meta.storeId= "storeName"; + meta.user = "100"; + auto result = service.DoAutoSync(devices, meta, tables); EXPECT_EQ(result, RDB_ERROR); }