1 /*
2  * Copyright (c) 2023 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 use ipc::parcel::{Deserialize, MsgParcel};
17 use ipc::remote::RemoteObj;
18 use ipc::IpcResult;
19 
20 use crate::ipc_conn::connect::ValueBucket;
21 use crate::ipc_conn::error::Error;
22 use crate::ipc_conn::ffi::ConnectService;
23 use crate::ipc_conn::function::CloudDB::{
24     Delete, GenerateIds, Heartbeat, Insert, Lock, Query, Unlock, Update,
25 };
26 use crate::ipc_conn::function::CloudServiceFunc::ConnectDatabase;
27 use crate::ipc_conn::*;
28 
29 pub(crate) type DatabaseStubResult<T> = Result<T, Error>;
30 
31 #[derive(Debug)]
32 pub(crate) struct LockInfo {
33     // Duration for which the cloud database is locked, in seconds.
34     pub(crate) interval: i32,
35 
36     // Session ID for locking the cloud database.
37     pub(crate) session_id: i32,
38 }
39 
40 impl Deserialize for LockInfo {
deserialize(parcel: &mut MsgParcel) -> IpcResult<Self>41     fn deserialize(parcel: &mut MsgParcel) -> IpcResult<Self> {
42         let interval = parcel.read::<i32>()?;
43         let session_id = parcel.read::<i32>()?;
44         let result = Self {
45             interval,
46             session_id,
47         };
48         Ok(result)
49     }
50 }
51 
52 pub(crate) struct DatabaseStub {
53     pub(crate) remote_obj: Option<RemoteObj>,
54 }
55 
56 impl DatabaseStub {
new( user_id: i32, bundle_name: &str, database: &Database, ) -> DatabaseStubResult<Self>57     pub(crate) fn new(
58         user_id: i32,
59         bundle_name: &str,
60         database: &Database,
61     ) -> DatabaseStubResult<Self> {
62         let mut msg_parcel = MsgParcel::new();
63 
64         msg_parcel
65             .write_string16(bundle_name)
66             .map_err(|_| Error::WriteMsgParcelFailed)?;
67         msg_parcel
68             .write(database)
69             .map_err(|_| Error::WriteMsgParcelFailed)?;
70 
71         let function_number = ConnectDatabase as u32;
72 
73         let remote_obj = unsafe { RemoteObj::from_ciremote(ConnectService(user_id)) }
74             .ok_or(Error::GetProxyObjectFailed)?;
75 
76         let mut receive = remote_obj
77             .send_request(function_number, &mut msg_parcel)
78             .map_err(|_| Error::SendRequestFailed)?;
79 
80         let result = receive
81             .read_remote()
82             .map_err(|_| Error::ReadMsgParcelFailed)?;
83         Ok(Self {
84             remote_obj: Some(result),
85         })
86     }
87 
generate_ids(&mut self, number: u32) -> DatabaseStubResult<Vec<String>>88     pub(crate) fn generate_ids(&mut self, number: u32) -> DatabaseStubResult<Vec<String>> {
89         #[derive(Default)]
90         struct Ids(Vec<String>);
91 
92         impl Deserialize for Ids {
93             fn deserialize(parcel: &mut MsgParcel) -> IpcResult<Self> {
94                 let length = parcel.read::<i32>()? as usize;
95                 let mut id_vec = Vec::with_capacity(length);
96                 for _ in 0..length {
97                     let value = parcel.read_string16()?;
98                     id_vec.push(value);
99                 }
100 
101                 let ids = Ids(id_vec.into_iter().collect());
102                 Ok(ids)
103             }
104         }
105 
106         let mut msg_parcel = MsgParcel::new();
107         msg_parcel
108             .write(&number)
109             .map_err(|_| Error::WriteMsgParcelFailed)?;
110 
111         let function_number = GenerateIds as u32;
112         let remote_obj = self
113             .remote_obj
114             .as_ref()
115             .ok_or(Error::CreateMsgParcelFailed)?;
116 
117         let mut receive = remote_obj
118             .send_request(function_number, &mut msg_parcel)
119             .map_err(|_| Error::SendRequestFailed)?;
120 
121         let error = receive
122             .read::<Error>()
123             .map_err(|_| Error::ReadMsgParcelFailed)?;
124         if !error.eq(&Error::Success) {
125             return Err(error);
126         }
127         let ids = receive
128             .read::<Ids>()
129             .map_err(|_| Error::ReadMsgParcelFailed)?
130             .0;
131         Ok(ids)
132     }
133 
insert( &mut self, table: &str, values: &ValueBuckets, extends: &ValueBuckets, ) -> DatabaseStubResult<Vec<Option<ValueBucket>>>134     pub(crate) fn insert(
135         &mut self,
136         table: &str,
137         values: &ValueBuckets,
138         extends: &ValueBuckets,
139     ) -> DatabaseStubResult<Vec<Option<ValueBucket>>> {
140         let mut msg_parcel = MsgParcel::new();
141 
142         msg_parcel
143             .write_string16(table)
144             .map_err(|_| Error::WriteMsgParcelFailed)?;
145         msg_parcel
146             .write(values)
147             .map_err(|_| Error::WriteMsgParcelFailed)?;
148         msg_parcel
149             .write(extends)
150             .map_err(|_| Error::WriteMsgParcelFailed)?;
151 
152         let function_number = Insert as u32;
153         let remote_obj = self
154             .remote_obj
155             .as_ref()
156             .ok_or(Error::CreateMsgParcelFailed)?;
157         let mut receive = remote_obj
158             .send_request(function_number, &mut msg_parcel)
159             .map_err(|_| Error::SendRequestFailed)?;
160 
161         let mut results = vec![];
162         let length = receive
163             .read::<i32>()
164             .map_err(|_| Error::ReadMsgParcelFailed)?;
165         for _ in 0..length {
166             let error = receive
167                 .read::<Error>()
168                 .map_err(|_| Error::ReadMsgParcelFailed)?;
169             if !error.eq(&Error::Success) {
170                 results.push(None);
171                 continue;
172             } else {
173                 let result = receive
174                     .read::<ValueBucket>()
175                     .map_err(|_| Error::ReadMsgParcelFailed)?;
176                 results.push(Some(result));
177             }
178         }
179         Ok(results)
180     }
181 
update( &mut self, table: &str, values: &ValueBuckets, extends: &ValueBuckets, ) -> DatabaseStubResult<Vec<Option<ValueBucket>>>182     pub(crate) fn update(
183         &mut self,
184         table: &str,
185         values: &ValueBuckets,
186         extends: &ValueBuckets,
187     ) -> DatabaseStubResult<Vec<Option<ValueBucket>>> {
188         let mut msg_parcel = MsgParcel::new();
189         msg_parcel
190             .write_string16(table)
191             .map_err(|_| Error::WriteMsgParcelFailed)?;
192         msg_parcel
193             .write(values)
194             .map_err(|_| Error::WriteMsgParcelFailed)?;
195         msg_parcel
196             .write(extends)
197             .map_err(|_| Error::WriteMsgParcelFailed)?;
198 
199         let function_number = Update as u32;
200         let remote_obj = self
201             .remote_obj
202             .as_ref()
203             .ok_or(Error::CreateMsgParcelFailed)?;
204         let mut receive = remote_obj
205             .send_request(function_number, &mut msg_parcel)
206             .map_err(|_| Error::SendRequestFailed)?;
207 
208         let mut results = vec![];
209         let length = receive
210             .read::<i32>()
211             .map_err(|_| Error::ReadMsgParcelFailed)?;
212         for _ in 0..length {
213             let error = receive
214                 .read::<Error>()
215                 .map_err(|_| Error::ReadMsgParcelFailed)?;
216             if !error.eq(&Error::Success) {
217                 results.push(None);
218                 continue;
219             } else {
220                 let result = receive
221                     .read::<ValueBucket>()
222                     .map_err(|_| Error::ReadMsgParcelFailed)?;
223                 results.push(Some(result));
224             }
225         }
226         Ok(results)
227     }
228 
delete( &mut self, table: &str, extends: &ValueBuckets, ) -> DatabaseStubResult<Vec<Option<ValueBucket>>>229     pub(crate) fn delete(
230         &mut self,
231         table: &str,
232         extends: &ValueBuckets,
233     ) -> DatabaseStubResult<Vec<Option<ValueBucket>>> {
234         let mut msg_parcel = MsgParcel::new();
235         msg_parcel
236             .write_string16(table)
237             .map_err(|_| Error::WriteMsgParcelFailed)?;
238         msg_parcel
239             .write(extends)
240             .map_err(|_| Error::WriteMsgParcelFailed)?;
241 
242         let function_number = Delete as u32;
243         let remote_obj = self
244             .remote_obj
245             .as_ref()
246             .ok_or(Error::CreateMsgParcelFailed)?;
247         let mut receive = remote_obj
248             .send_request(function_number, &mut msg_parcel)
249             .map_err(|_| Error::SendRequestFailed)?;
250 
251         let mut results = vec![];
252         let length = receive
253             .read::<i32>()
254             .map_err(|_| Error::ReadMsgParcelFailed)?;
255         for _ in 0..length {
256             let error = receive
257                 .read::<Error>()
258                 .map_err(|_| Error::ReadMsgParcelFailed)?;
259             if !error.eq(&Error::Success) {
260                 results.push(None);
261                 continue;
262             } else {
263                 let result = receive
264                     .read::<ValueBucket>()
265                     .map_err(|_| Error::ReadMsgParcelFailed)?;
266                 results.push(Some(result));
267             }
268         }
269         Ok(results)
270     }
271 
query_values( &mut self, table: &str, columns: &[String], result_limit: i32, cursor: &str, ) -> DatabaseStubResult<CloudData>272     pub(crate) fn query_values(
273         &mut self,
274         table: &str,
275         columns: &[String],
276         result_limit: i32,
277         cursor: &str,
278     ) -> DatabaseStubResult<CloudData> {
279         let mut msg_parcel = MsgParcel::new();
280         msg_parcel
281             .write_string16(table)
282             .map_err(|_| Error::WriteMsgParcelFailed)?;
283         msg_parcel
284             .write_string16_vec(columns)
285             .map_err(|_| Error::WriteMsgParcelFailed)?;
286         msg_parcel
287             .write(&result_limit)
288             .map_err(|_| Error::WriteMsgParcelFailed)?;
289         msg_parcel
290             .write_string16(cursor)
291             .map_err(|_| Error::WriteMsgParcelFailed)?;
292 
293         let function_number = Query as u32;
294         let remote_obj = self
295             .remote_obj
296             .as_ref()
297             .ok_or(Error::CreateMsgParcelFailed)?;
298         let mut receive = remote_obj
299             .send_request(function_number, &mut msg_parcel)
300             .map_err(|_| Error::SendRequestFailed)?;
301 
302         let error = receive
303             .read::<Error>()
304             .map_err(|_| Error::ReadMsgParcelFailed)?;
305         if !error.eq(&Error::Success) {
306             return Err(error);
307         }
308         let result = receive
309             .read::<CloudData>()
310             .map_err(|_| Error::ReadMsgParcelFailed)?;
311         Ok(result)
312     }
313 
lock(&mut self, interval: i32) -> DatabaseStubResult<LockInfo>314     pub(crate) fn lock(&mut self, interval: i32) -> DatabaseStubResult<LockInfo> {
315         let mut msg_parcel = MsgParcel::new();
316         msg_parcel
317             .write(&interval)
318             .map_err(|_| Error::WriteMsgParcelFailed)?;
319 
320         let function_number = Lock as u32;
321         let remote_obj = self
322             .remote_obj
323             .as_ref()
324             .ok_or(Error::CreateMsgParcelFailed)?;
325         let mut receive = remote_obj
326             .send_request(function_number, &mut msg_parcel)
327             .map_err(|_| Error::SendRequestFailed)?;
328 
329         let error = receive
330             .read::<Error>()
331             .map_err(|_| Error::ReadMsgParcelFailed)?;
332         if !error.eq(&Error::Success) {
333             return Err(error);
334         }
335         let result = receive
336             .read::<LockInfo>()
337             .map_err(|_| Error::ReadMsgParcelFailed)?;
338         Ok(result)
339     }
340 
unlock(&mut self, session_id: i32) -> DatabaseStubResult<()>341     pub(crate) fn unlock(&mut self, session_id: i32) -> DatabaseStubResult<()> {
342         let mut msg_parcel = MsgParcel::new();
343         msg_parcel
344             .write(&session_id)
345             .map_err(|_| Error::WriteMsgParcelFailed)?;
346 
347         let function_number = Unlock as u32;
348         let remote_obj = self
349             .remote_obj
350             .as_ref()
351             .ok_or(Error::CreateMsgParcelFailed)?;
352         let mut receive = remote_obj
353             .send_request(function_number, &mut msg_parcel)
354             .map_err(|_| Error::SendRequestFailed)?;
355 
356         let error = receive
357             .read::<Error>()
358             .map_err(|_| Error::ReadMsgParcelFailed)?;
359         if !error.eq(&Error::Success) {
360             return Err(error);
361         }
362         Ok(())
363     }
364 
heartbeat(&self, session_id: i32) -> DatabaseStubResult<LockInfo>365     pub(crate) fn heartbeat(&self, session_id: i32) -> DatabaseStubResult<LockInfo> {
366         let mut msg_parcel = MsgParcel::new();
367         msg_parcel
368             .write(&session_id)
369             .map_err(|_| Error::WriteMsgParcelFailed)?;
370 
371         let function_number = Heartbeat as u32;
372         let remote_obj = self
373             .remote_obj
374             .as_ref()
375             .ok_or(Error::CreateMsgParcelFailed)?;
376         let mut receive = remote_obj
377             .send_request(function_number, &mut msg_parcel)
378             .map_err(|_| Error::SendRequestFailed)?;
379 
380         let error = receive
381             .read::<Error>()
382             .map_err(|_| Error::ReadMsgParcelFailed)?;
383         if !error.eq(&Error::Success) {
384             return Err(error);
385         }
386         let result = receive
387             .read::<LockInfo>()
388             .map_err(|_| Error::ReadMsgParcelFailed)?;
389         Ok(result)
390     }
391 }
392