• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef DISTRIBUTEDDATASERVICE_RDB_SERVICE_H
17 #define DISTRIBUTEDDATASERVICE_RDB_SERVICE_H
18 
19 #include <map>
20 #include <mutex>
21 #include <string>
22 
23 #include "cloud/cloud_event.h"
24 #include "commonevent/data_change_event.h"
25 #include "commonevent/set_searchable_event.h"
26 #include "concurrent_map.h"
27 #include "crypto/crypto_manager.h"
28 #include "feature/static_acts.h"
29 #include "metadata/secret_key_meta_data.h"
30 #include "metadata/store_meta_data.h"
31 #include "rdb_notifier_proxy.h"
32 #include "rdb_query.h"
33 #include "rdb_service_stub.h"
34 #include "rdb_watcher.h"
35 #include "snapshot/bind_event.h"
36 #include "store/auto_cache.h"
37 #include "store/general_store.h"
38 #include "store/general_value.h"
39 #include "store_observer.h"
40 #include "visibility.h"
41 #include "process_communicator_impl.h"
42 
43 namespace OHOS::DistributedRdb {
44 using namespace OHOS::AppDistributedKv;
45 class RdbServiceImpl : public RdbServiceStub {
46 public:
47     using StoreMetaData = OHOS::DistributedData::StoreMetaData;
48     using SecretKeyMetaData = DistributedData::SecretKeyMetaData;
49     using DetailAsync = DistributedData::GeneralStore::DetailAsync;
50     using Database = DistributedData::Database;
51     using Handler = std::function<void(int, std::map<std::string, std::vector<std::string>> &)>;
52     using StoreInfo = DistributedData::StoreInfo;
53     RdbServiceImpl();
54     virtual ~RdbServiceImpl();
55 
56     /* IPC interface */
57     std::string ObtainDistributedTableName(const RdbSyncerParam &param, const std::string &device,
58         const std::string &table) override;
59 
60     int32_t InitNotifier(const RdbSyncerParam &param, sptr<IRemoteObject> notifier) override;
61 
62     int32_t SetDistributedTables(const RdbSyncerParam &param, const std::vector<std::string> &tables,
63         const std::vector<Reference> &references, bool isRebuild, int32_t type = DISTRIBUTED_DEVICE) override;
64 
65     std::pair<int32_t, std::shared_ptr<ResultSet>> RemoteQuery(const RdbSyncerParam& param, const std::string& device,
66         const std::string& sql, const std::vector<std::string>& selectionArgs) override;
67 
68     int32_t Sync(const RdbSyncerParam &param, const Option &option, const PredicatesMemo &predicates,
69         const AsyncDetail &async) override;
70 
71     int32_t Subscribe(const RdbSyncerParam &param,
72                       const SubscribeOption &option,
73                       std::shared_ptr<RdbStoreObserver> observer) override;
74 
75     int32_t UnSubscribe(const RdbSyncerParam &param, const SubscribeOption &option,
76         std::shared_ptr<RdbStoreObserver>observer) override;
77 
78     int32_t RegisterAutoSyncCallback(const RdbSyncerParam& param,
79         std::shared_ptr<DetailProgressObserver> observer) override;
80 
81     int32_t UnregisterAutoSyncCallback(const RdbSyncerParam& param,
82         std::shared_ptr<DetailProgressObserver> observer) override;
83 
84     int32_t ResolveAutoLaunch(const std::string &identifier, DistributedDB::AutoLaunchParam &param) override;
85 
86     int32_t OnAppExit(pid_t uid, pid_t pid, uint32_t tokenId, const std::string &bundleName) override;
87 
88     int32_t OnFeatureExit(pid_t uid, pid_t pid, uint32_t tokenId, const std::string &bundleName) override;
89 
90     int32_t Delete(const RdbSyncerParam &param) override;
91 
92     std::pair<int32_t, std::shared_ptr<ResultSet>> QuerySharingResource(const RdbSyncerParam& param,
93         const PredicatesMemo& predicates, const std::vector<std::string>& columns) override;
94 
95     int32_t OnBind(const BindInfo &bindInfo) override;
96 
97     int32_t OnReady(const std::string &device) override;
98 
99     int32_t OnInitialize() override;
100 
101     int32_t NotifyDataChange(const RdbSyncerParam &param, const RdbChangedData &rdbChangedData,
102         const RdbNotifyConfig &rdbNotifyConfig) override;
103     int32_t SetSearchable(const RdbSyncerParam& param, bool isSearchable) override;
104     int32_t Disable(const RdbSyncerParam& param) override;
105     int32_t Enable(const RdbSyncerParam& param) override;
106 
107     int32_t BeforeOpen(RdbSyncerParam &param) override;
108 
109     int32_t AfterOpen(const RdbSyncerParam &param) override;
110 
111     int32_t ReportStatistic(const RdbSyncerParam &param, const RdbStatEvent &statEvent) override;
112 
113     int32_t GetPassword(const RdbSyncerParam &param, std::vector<std::vector<uint8_t>> &password) override;
114 
115     std::pair<int32_t, uint32_t> LockCloudContainer(const RdbSyncerParam &param) override;
116 
117     int32_t UnlockCloudContainer(const RdbSyncerParam &param) override;
118 
119     int32_t GetDebugInfo(const RdbSyncerParam &param, std::map<std::string, RdbDebugInfo> &debugInfo) override;
120 
121     int32_t GetDfxInfo(const RdbSyncerParam &param, DistributedRdb::RdbDfxInfo &dfxInfo) override;
122 
123     int32_t VerifyPromiseInfo(const RdbSyncerParam &param) override;
124 
125 private:
126     using Watchers = DistributedData::AutoCache::Watchers;
127     using StaticActs = DistributedData::StaticActs;
128     using DBStatus = DistributedDB::DBStatus;
129     using SyncResult = std::pair<std::vector<std::string>, std::map<std::string, DBStatus>>;
130     using AutoCache = DistributedData::AutoCache;
131     using CryptoManager = DistributedData::CryptoManager;
132     struct SyncAgent {
133         SyncAgent() = default;
134         explicit SyncAgent(const std::string &bundleName);
135         int32_t count_ = 0;
136         std::map<std::string, int> callBackStores_;
137         std::string bundleName_;
138         sptr<RdbNotifierProxy> notifier_ = nullptr;
139         std::shared_ptr<RdbWatcher> watcher_ = nullptr;
140         void SetNotifier(sptr<RdbNotifierProxy> notifier);
141         void SetWatcher(std::shared_ptr<RdbWatcher> watcher);
142     };
143     using SyncAgents = std::map<int32_t, SyncAgent>;
144 
145     class RdbStatic : public StaticActs {
146     public:
~RdbStatic()147         ~RdbStatic() override {};
148         int32_t OnAppUninstall(const std::string &bundleName, int32_t user, int32_t index) override;
149         int32_t OnAppUpdate(const std::string &bundleName, int32_t user, int32_t index) override;
150         int32_t OnClearAppStorage(const std::string &bundleName, int32_t user, int32_t index, int32_t tokenId) override;
151     private:
152         static constexpr inline int32_t INVALID_TOKENID = 0;
153         int32_t CloseStore(const std::string &bundleName, int32_t user, int32_t index,
154             int32_t tokenId = INVALID_TOKENID) const;
155     };
156 
157     class Factory {
158     public:
159         Factory();
160         ~Factory();
161     private:
162         std::shared_ptr<RdbServiceImpl> product_;
163         std::shared_ptr<RdbStatic> staticActs_;
164     };
165 
166     static constexpr inline uint32_t WAIT_TIME = 30 * 1000;
167     static constexpr inline uint32_t SHARE_WAIT_TIME = 60; // seconds
168 
169     void RegisterRdbServiceInfo();
170 
171     void RegisterHandler();
172 
173     void RegisterEvent();
174 
175     void DumpRdbServiceInfo(int fd, std::map<std::string, std::vector<std::string>> &params);
176 
177     void DoCloudSync(const RdbSyncerParam &param, const Option &option, const PredicatesMemo &predicates,
178         const AsyncDetail &async);
179 
180     void DoCompensateSync(const DistributedData::BindEvent& event);
181 
182     int DoSync(const RdbSyncerParam &param, const Option &option, const PredicatesMemo &predicates,
183         const AsyncDetail &async);
184 
185     int DoAutoSync(
186         const std::vector<std::string> &devices, const Database &dataBase, std::vector<std::string> tableNames);
187 
188     std::vector<std::string> GetReuseDevice(const std::vector<std::string> &devices, const StoreMetaData &metaData);
189     int DoOnlineSync(const std::vector<std::string> &devices, const Database &dataBase);
190 
191     int DoDataChangeSync(const StoreInfo &storeInfo, const RdbChangedData &rdbChangedData);
192 
193     Watchers GetWatchers(uint32_t tokenId, const std::string &storeName);
194 
195     DetailAsync GetCallbacks(uint32_t tokenId, const std::string &storeName);
196 
197     std::shared_ptr<DistributedData::GeneralStore> GetStore(const RdbSyncerParam& param);
198 
199     std::shared_ptr<DistributedData::GeneralStore> GetStore(const StoreMetaData &storeMetaData);
200 
201     void OnAsyncComplete(uint32_t tokenId, pid_t pid, uint32_t seqNum, Details &&result);
202 
203     int32_t Upgrade(const RdbSyncerParam &param, const StoreMetaData &old);
204 
205     void GetSchema(const RdbSyncerParam &param);
206 
207     bool IsPostImmediately(const int32_t callingPid, const RdbNotifyConfig &rdbNotifyConfig, StoreInfo &storeInfo,
208         DistributedData::DataChangeEvent::EventInfo &eventInfo, const std::string &storeName);
209 
210     bool TryUpdateDeviceId(const RdbSyncerParam &param, const StoreMetaData &oldMeta, StoreMetaData &meta);
211 
212     void SaveLaunchInfo(StoreMetaData &meta);
213 
214     static bool IsValidAccess(const std::string& bundleName, const std::string& storeName);
215 
216     static bool IsValidPath(const std::string& param);
217 
218     static bool IsValidCustomDir(const std::string &customDir, int32_t upLimit);
219 
220     static bool IsValidParam(const RdbSyncerParam &param);
221 
222     static StoreMetaData GetStoreMetaData(const RdbSyncerParam &param);
223 
224     static std::pair<bool, StoreMetaData> LoadStoreMetaData(const RdbSyncerParam &param);
225 
226     static std::string GetPath(const RdbSyncerParam &param);
227 
228     static StoreMetaData GetStoreMetaData(const Database &dataBase);
229 
230     static std::pair<int32_t, std::shared_ptr<DistributedData::Cursor>> AllocResource(
231         StoreInfo& storeInfo, std::shared_ptr<RdbQuery> rdbQuery);
232 
233     static Details HandleGenDetails(const DistributedData::GenDetails &details);
234 
235     static std::string TransferStringToHex(const std::string& origStr);
236 
237     static std::string RemoveSuffix(const std::string& name);
238 
239     static std::pair<int32_t, int32_t> GetInstIndexAndUser(uint32_t tokenId, const std::string &bundleName);
240 
241     static std::string GetSubUser(const int32_t subUser);
242 
243     static bool SaveAppIDMeta(const StoreMetaData &meta, const StoreMetaData &old);
244 
245     static void SetReturnParam(const StoreMetaData &metadata, RdbSyncerParam &param);
246 
247     static bool IsNeedMetaSync(const StoreMetaData &meta, const std::vector<std::string> &uuids);
248 
249     static SyncResult ProcessResult(const std::map<std::string, int32_t> &results);
250 
251     static StoreInfo GetStoreInfo(const RdbSyncerParam &param);
252 
253     static int32_t SaveDebugInfo(const StoreMetaData &metaData, const RdbSyncerParam &param);
254 
255     static int32_t SaveDfxInfo(const StoreMetaData &metaData, const RdbSyncerParam &param);
256 
257     static int32_t SavePromiseInfo(const StoreMetaData &metaData, const RdbSyncerParam &param);
258 
259     static int32_t PostSearchEvent(int32_t evtId, const RdbSyncerParam& param,
260         DistributedData::SetSearchableEvent::EventInfo &eventInfo);
261 
262     static void UpdateMeta(const StoreMetaData &meta, const StoreMetaData &localMeta, AutoCache::Store store);
263 
264     std::vector<uint8_t> LoadSecretKey(const StoreMetaData &metaData, CryptoManager::SecretKeyType secretKeyType);
265 
266     void SaveSecretKeyMeta(const StoreMetaData &metaData, const std::vector<uint8_t> &password);
267 
268     static Factory factory_;
269     ConcurrentMap<uint32_t, SyncAgents> syncAgents_;
270     std::shared_ptr<ExecutorPool> executors_;
271     ConcurrentMap<int32_t, std::map<std::string, ExecutorPool::TaskId>> heartbeatTaskIds_;
272 };
273 } // namespace OHOS::DistributedRdb
274 #endif