settings/
storage.rs

1// Copyright 2021 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5//! This module contains types used for sending and receiving messages to and from the storage
6//! agent.
7
8use crate::base::{SettingInfo, SettingType};
9use fuchsia_trace as ftrace;
10use settings_storage::UpdateState;
11
12/// `Payload` wraps the request and response payloads.
13#[derive(Clone, PartialEq, Debug)]
14pub enum Payload {
15    Request(StorageRequest),
16    Response(StorageResponse),
17}
18
19/// `StorageRequest` contains all of the requests that can be made to the storage agent.
20#[derive(Clone, PartialEq, Debug)]
21pub enum StorageRequest {
22    /// A read requests for the corresponding [`StorageInfo`] of this `StorageType`.
23    Read(StorageType, ftrace::Id),
24    /// A write requests for this [`StorageInfo`].
25    Write(StorageInfo, ftrace::Id),
26}
27
28#[derive(Clone, PartialEq, Debug)]
29pub enum StorageType {
30    SettingType(SettingType),
31}
32
33impl From<SettingType> for StorageType {
34    fn from(setting_type: SettingType) -> Self {
35        StorageType::SettingType(setting_type)
36    }
37}
38
39#[derive(Clone, PartialEq, Debug)]
40pub enum StorageInfo {
41    SettingInfo(SettingInfo),
42}
43
44impl From<SettingInfo> for StorageInfo {
45    fn from(setting_info: SettingInfo) -> Self {
46        StorageInfo::SettingInfo(setting_info)
47    }
48}
49
50/// `StorageResponse` contains the corresponding result types to the matching [`StorageRequest`]
51/// variants of the same name.
52#[derive(Clone, PartialEq, Debug)]
53pub enum StorageResponse {
54    /// The storage info read from storage in response to a [`StorageRequest::Read`]
55    Read(StorageInfo),
56    /// The result of a write request with either the [`UpdateState`] after a successful write
57    /// or a formatted error describing why the write could not occur.
58    Write(Result<UpdateState, Error>),
59}
60
61/// `Error` encapsulates a formatted error the occurs due to write failures.
62#[derive(Clone, PartialEq, Debug)]
63pub struct Error {
64    /// The error message.
65    pub message: String,
66}
67
68#[cfg(test)]
69pub(crate) mod testing {
70    use anyhow::Error;
71    use fidl_fuchsia_stash::{
72        StoreAccessorMarker, StoreAccessorProxy, StoreAccessorRequest, Value,
73    };
74    use fuchsia_async as fasync;
75    use fuchsia_inspect::component;
76    use futures::lock::Mutex;
77    use futures::prelude::*;
78    use serde::{Deserialize, Serialize};
79    use settings_storage::device_storage::{DeviceStorage, DeviceStorageCompatible};
80    use settings_storage::stash_logger::StashInspectLogger;
81    use settings_storage::storage_factory::{
82        DefaultLoader, InitializationState, NoneT, StorageAccess, StorageFactory,
83    };
84    use std::any::Any;
85    use std::collections::HashMap;
86    use std::rc::Rc;
87
88    #[derive(PartialEq)]
89    pub(crate) enum StashAction {
90        Get,
91        Flush,
92        Set,
93    }
94
95    pub(crate) struct StashStats {
96        actions: Vec<StashAction>,
97    }
98
99    impl StashStats {
100        pub(crate) fn new() -> Self {
101            StashStats { actions: Vec::new() }
102        }
103
104        pub(crate) fn record(&mut self, action: StashAction) {
105            self.actions.push(action);
106        }
107    }
108
109    /// Storage that does not write to disk, for testing.
110    pub(crate) struct InMemoryStorageFactory {
111        initial_data: HashMap<&'static str, String>,
112        device_storage_cache: Mutex<InitializationState<DeviceStorage>>,
113        inspect_handle: Rc<Mutex<StashInspectLogger>>,
114    }
115
116    impl Default for InMemoryStorageFactory {
117        fn default() -> Self {
118            Self::new()
119        }
120    }
121
122    const INITIALIZATION_ERROR: &str =
123        "Cannot initialize an already accessed device storage. Make \
124        sure you're not retrieving a DeviceStorage before passing InMemoryStorageFactory to an \
125        EnvironmentBuilder. That must be done after. If you need initial data, use \
126        InMemoryStorageFactory::with_initial_data";
127
128    impl InMemoryStorageFactory {
129        /// Constructs a new `InMemoryStorageFactory` with the ability to create a [`DeviceStorage`]
130        /// that can only read and write to the storage keys passed in.
131        pub fn new() -> Self {
132            InMemoryStorageFactory {
133                initial_data: HashMap::new(),
134                device_storage_cache: Mutex::new(InitializationState::new()),
135                inspect_handle: Rc::new(Mutex::new(StashInspectLogger::new(
136                    component::inspector().root(),
137                ))),
138            }
139        }
140
141        /// Constructs a new `InMemoryStorageFactory` with the data written to stash. This simulates
142        /// the data existing in storage before the RestoreAgent reads it.
143        pub fn with_initial_data<T>(data: &T) -> Self
144        where
145            T: DeviceStorageCompatible,
146        {
147            let mut map = HashMap::new();
148            let _ = map.insert(T::KEY, serde_json::to_string(data).unwrap());
149            InMemoryStorageFactory {
150                initial_data: map,
151                device_storage_cache: Mutex::new(InitializationState::new()),
152                inspect_handle: Rc::new(Mutex::new(StashInspectLogger::new(
153                    component::inspector().root(),
154                ))),
155            }
156        }
157
158        /// Helper method to simplify setup for `InMemoryStorageFactory` in tests.
159        pub(crate) async fn initialize_storage<T>(&self)
160        where
161            T: DeviceStorageCompatible,
162        {
163            self.initialize_storage_for_key(T::KEY).await;
164        }
165
166        async fn initialize_storage_for_key(&self, key: &'static str) {
167            match &mut *self.device_storage_cache.lock().await {
168                InitializationState::Initializing(initial_keys, _) => {
169                    let _ = initial_keys.insert(key, None);
170                }
171                InitializationState::Initialized(_) => panic!("{}", INITIALIZATION_ERROR),
172                _ => unreachable!(),
173            }
174        }
175
176        async fn initialize_storage_for_key_with_loader(
177            &self,
178            key: &'static str,
179            loader: Box<dyn Any>,
180        ) {
181            match &mut *self.device_storage_cache.lock().await {
182                InitializationState::Initializing(initial_keys, _) => {
183                    let _ = initial_keys.insert(key, Some(loader));
184                }
185                InitializationState::Initialized(_) => panic!("{}", INITIALIZATION_ERROR),
186                _ => unreachable!(),
187            }
188        }
189
190        /// Retrieve the [`DeviceStorage`] singleton.
191        pub(crate) async fn get_device_storage(&self) -> Rc<DeviceStorage> {
192            let initialization = &mut *self.device_storage_cache.lock().await;
193            match initialization {
194                InitializationState::Initializing(initial_keys, _) => {
195                    let mut device_storage = DeviceStorage::with_stash_proxy(
196                        initial_keys.drain(),
197                        || {
198                            let (stash_proxy, _) = spawn_stash_proxy();
199                            stash_proxy
200                        },
201                        Rc::clone(&self.inspect_handle),
202                    );
203                    device_storage.set_caching_enabled(false);
204                    device_storage.set_debounce_writes(false);
205
206                    // write initial data to storage
207                    for (&key, data) in &self.initial_data {
208                        device_storage
209                            .write_str(key, data.clone())
210                            .await
211                            .expect("Failed to write initial data");
212                    }
213
214                    let device_storage = Rc::new(device_storage);
215                    *initialization = InitializationState::Initialized(Rc::clone(&device_storage));
216                    device_storage
217                }
218                InitializationState::Initialized(device_storage) => Rc::clone(device_storage),
219                _ => unreachable!(),
220            }
221        }
222    }
223
224    impl StorageFactory for InMemoryStorageFactory {
225        type Storage = DeviceStorage;
226
227        async fn initialize<T>(&self) -> Result<(), Error>
228        where
229            T: StorageAccess<Storage = DeviceStorage>,
230        {
231            self.initialize_storage_for_key(T::STORAGE_KEY).await;
232            Ok(())
233        }
234
235        async fn initialize_with_loader<T, L>(&self, loader: L) -> Result<(), Error>
236        where
237            T: StorageAccess<Storage = DeviceStorage>,
238            L: DefaultLoader<Result = T::Data> + 'static,
239        {
240            self.initialize_storage_for_key_with_loader(
241                T::STORAGE_KEY,
242                Box::new(loader) as Box<dyn Any>,
243            )
244            .await;
245            Ok(())
246        }
247
248        async fn get_store(&self) -> Rc<DeviceStorage> {
249            self.get_device_storage().await
250        }
251    }
252
253    fn spawn_stash_proxy() -> (StoreAccessorProxy, Rc<Mutex<StashStats>>) {
254        let (stash_proxy, mut stash_stream) =
255            fidl::endpoints::create_proxy_and_stream::<StoreAccessorMarker>();
256        let stats = Rc::new(Mutex::new(StashStats::new()));
257        let stats_clone = stats.clone();
258        fasync::Task::local(async move {
259            let mut stored_value: Option<Value> = None;
260            let mut stored_key: Option<String> = None;
261
262            while let Some(req) = stash_stream.try_next().await.unwrap() {
263                #[allow(unreachable_patterns)]
264                match req {
265                    StoreAccessorRequest::GetValue { key, responder } => {
266                        stats_clone.lock().await.record(StashAction::Get);
267                        if let Some(key_string) = stored_key {
268                            assert_eq!(key, key_string);
269                        }
270                        stored_key = Some(key);
271
272                        let value = stored_value.as_ref().map(|value| match value {
273                            Value::Intval(v) => Value::Intval(*v),
274                            Value::Floatval(v) => Value::Floatval(*v),
275                            Value::Boolval(v) => Value::Boolval(*v),
276                            Value::Stringval(v) => Value::Stringval(v.clone()),
277                            Value::Bytesval(buffer) => {
278                                let opts = zx::VmoChildOptions::SNAPSHOT_AT_LEAST_ON_WRITE;
279                                Value::Bytesval(fidl_fuchsia_mem::Buffer {
280                                    vmo: buffer.vmo.create_child(opts, 0, buffer.size).unwrap(),
281                                    size: buffer.size,
282                                })
283                            }
284                        });
285                        responder.send(value).unwrap();
286                    }
287                    StoreAccessorRequest::SetValue { key, val, control_handle: _ } => {
288                        stats_clone.lock().await.record(StashAction::Set);
289                        if let Some(key_string) = stored_key {
290                            assert_eq!(key, key_string);
291                        }
292                        stored_key = Some(key);
293                        stored_value = Some(val);
294                    }
295                    StoreAccessorRequest::Flush { responder } => {
296                        stats_clone.lock().await.record(StashAction::Flush);
297                        let _ = responder.send(Ok(()));
298                    }
299                    _ => {}
300                }
301            }
302        })
303        .detach();
304        (stash_proxy, stats)
305    }
306
307    const VALUE0: i32 = 3;
308    const VALUE1: i32 = 33;
309
310    #[derive(PartialEq, Clone, Serialize, Deserialize, Debug)]
311    struct TestStruct {
312        value: i32,
313    }
314
315    impl DeviceStorageCompatible for TestStruct {
316        type Loader = NoneT;
317        const KEY: &'static str = "testkey";
318    }
319    impl Default for TestStruct {
320        fn default() -> Self {
321            TestStruct { value: VALUE0 }
322        }
323    }
324
325    #[fuchsia::test(allow_stalls = false)]
326    async fn test_in_memory_storage() {
327        let factory = InMemoryStorageFactory::new();
328        factory.initialize_storage::<TestStruct>().await;
329
330        let store_1 = factory.get_device_storage().await;
331        let store_2 = factory.get_device_storage().await;
332
333        // Write initial data through first store.
334        let test_struct = TestStruct { value: VALUE0 };
335
336        // Ensure writing from store1 ends up in store2
337        test_write_propagation(store_1.clone(), store_2.clone(), test_struct).await;
338
339        let test_struct_2 = TestStruct { value: VALUE1 };
340        // Ensure writing from store2 ends up in store1
341        test_write_propagation(store_2.clone(), store_1.clone(), test_struct_2).await;
342    }
343
344    async fn test_write_propagation(
345        store_1: Rc<DeviceStorage>,
346        store_2: Rc<DeviceStorage>,
347        data: TestStruct,
348    ) {
349        assert!(store_1.write(&data).await.is_ok());
350
351        // Ensure it is read in from second store.
352        let retrieved_struct = store_2.get().await;
353        assert_eq!(data, retrieved_struct);
354    }
355}
settings/storage.rs

settings/
storage.rs
