Skip to main content

millipede_core/storage/
handle.rs

1use std::{fmt, sync::Arc};
2
3use super::{Dataset, KeyValueStore, RequestQueue, StorageClient, StorageResult};
4
5/// Open storage resources shared by crawler contexts.
6///
7/// ```
8/// # use std::sync::Arc;
9/// # use millipede_core::storage::{Dataset, KeyValueStore, RequestQueue, StorageClient, StorageHandle};
10/// # fn build(c: Arc<dyn StorageClient>, d: Arc<dyn Dataset>, k: Arc<dyn KeyValueStore>, q: Arc<dyn RequestQueue>) {
11/// let storage = StorageHandle::new(c, d, k, q);
12/// let _default_dataset = storage.dataset();
13/// # }
14/// ```
15#[derive(Clone)]
16pub struct StorageHandle {
17    client: Arc<dyn StorageClient>,
18    dataset: Arc<dyn Dataset>,
19    key_value_store: Arc<dyn KeyValueStore>,
20    request_queue: Arc<dyn RequestQueue>,
21}
22
23impl StorageHandle {
24    /// Wraps a client and its already-opened default resources.
25    pub fn new(
26        client: Arc<dyn StorageClient>,
27        dataset: Arc<dyn Dataset>,
28        key_value_store: Arc<dyn KeyValueStore>,
29        request_queue: Arc<dyn RequestQueue>,
30    ) -> Self {
31        Self {
32            client,
33            dataset,
34            key_value_store,
35            request_queue,
36        }
37    }
38
39    /// Returns the default dataset.
40    pub fn dataset(&self) -> &Arc<dyn Dataset> {
41        &self.dataset
42    }
43
44    /// Returns the default key-value store.
45    pub fn key_value_store(&self) -> &Arc<dyn KeyValueStore> {
46        &self.key_value_store
47    }
48
49    /// Returns the default request queue.
50    pub fn request_queue(&self) -> &Arc<dyn RequestQueue> {
51        &self.request_queue
52    }
53
54    /// Opens a named dataset through the underlying client.
55    pub async fn dataset_named(&self, name: &str) -> StorageResult<Arc<dyn Dataset>> {
56        self.client.open_dataset(Some(name)).await
57    }
58
59    /// Opens a named key-value store through the underlying client.
60    pub async fn kvs_named(&self, name: &str) -> StorageResult<Arc<dyn KeyValueStore>> {
61        self.client.open_key_value_store(Some(name)).await
62    }
63
64    /// Returns the storage backend client.
65    pub fn client(&self) -> &Arc<dyn StorageClient> {
66        &self.client
67    }
68}
69
70impl fmt::Debug for StorageHandle {
71    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
72        formatter
73            .debug_struct("StorageHandle")
74            .field("client", &"<dyn StorageClient>")
75            .field("dataset", &"<dyn Dataset>")
76            .field("key_value_store", &"<dyn KeyValueStore>")
77            .field("request_queue", &"<dyn RequestQueue>")
78            .finish()
79    }
80}