Skip to main content

coven/
builder_read_only.rs

1//! Open a store for reading only, beside a handle that has it open.
2
3use super::*;
4
5impl CovenBuilder {
6    /// Opens the store for reading only, alongside a handle that has it open.
7    /// Its shared lock protects both read connections and local cache metadata.
8    /// It runs no migration and refuses a database whose schema is newer,
9    /// that holds no coven tables, or whose indexes were built with
10    /// other versions of the app's collations and functions.
11    /// File reads connect using saved settings and custody credentials when present.
12    pub async fn open_read_only(
13        mut self,
14        store: StoreId,
15    ) -> Result<CovenReadHandle, ReadOnlyOpenError> {
16        let directory = self.directories.store_dir(&store);
17        let ids = self.ids.clone();
18        let clock = self.clock.clone();
19        // A read-only handle cannot persist a cooldown; it holds its own requests.
20        let waits = Arc::new(coven_sync::RetryWaits::in_memory(clock.clone()));
21        let connector = self.connector();
22        let transfers = self.transfers.clone();
23        let files = self.files.clone();
24        let database = self.database(directory.clone())?;
25        // Before the swap's marker exists, only the record shows that a
26        // replacement is moving the files a reader would open (ยง19.3).
27        refuse_unfinished_replacement(&directory, store)?;
28        refuse_unfinished_deletion(&directory, store)?;
29        let database = database.open_read_only().await?;
30        if let Some(identity) = database.store_state().await?.store {
31            check_store_settings(&identity, &directory)?;
32        }
33        let device = directory.settings().map_err(CovenError::from)?.device_id;
34        let oauth = self.oauth_exchange();
35        let in_directory = directory.clone();
36        let bugs = directory.bugs().clone();
37        let (credentials, data) =
38            crate::task::blocking_completing("read the saved credentials", bugs, move || {
39                let credentials = device_credentials(self.keychain()?, store, in_directory, oauth);
40                let data = credentials.connection()?;
41                Ok::<_, SyncError>((credentials, data))
42            })
43            .await
44            .map_err(SyncError::from)??;
45        let storage: Option<Arc<dyn Storage>> = match data {
46            Some(data) => {
47                let storage = connector
48                    .connect(
49                        data.location,
50                        coven_storage::ProviderAuth::new(data.credentials, credentials),
51                        device,
52                        Arc::new(crate::storage::NoPublications),
53                        waits.clone(),
54                        transfers.clone(),
55                    )
56                    .await
57                    .map_err(SyncError::from)?;
58                storage.check_location_claim(store).await.map_err(SyncError::from)?;
59                Some(storage)
60            }
61            None => None,
62        };
63        let files = coven_sync::Files::read_only(
64            coven_database::FileDatabase::new(database.clone()),
65            directory,
66            storage,
67            Arc::new(coven_sync::SequenceState::new()),
68            waits,
69            ids,
70            transfers,
71            files,
72            clock,
73            coven_foundation::network_watch::NetworkWatch::unwatched().view(),
74        );
75        Ok(CovenReadHandle::new(database, files))
76    }
77}