aura_composition/adapters/
storage.rs

1//! Storage handler adapter
2
3use crate::adapters::collect_ops;
4use crate::adapters::utils::{deserialize_operation_params, serialize_operation_result};
5use crate::registry::{HandlerContext, HandlerError, RegistrableHandler};
6use async_trait::async_trait;
7use aura_core::effects::{StorageCoreEffects, StorageExtendedEffects};
8use aura_core::{EffectType, ExecutionMode};
9use aura_effects::storage::FilesystemStorageHandler;
10use std::sync::Arc;
11
12/// Adapter for FilesystemStorageHandler
13pub struct StorageHandlerAdapter {
14    core: Arc<dyn StorageCoreEffects>,
15    extended: Option<Arc<dyn StorageExtendedEffects>>,
16}
17
18impl StorageHandlerAdapter {
19    pub fn new(handler: FilesystemStorageHandler) -> Self {
20        let handler = Arc::new(handler);
21        let core: Arc<dyn StorageCoreEffects> = handler.clone();
22        let extended: Arc<dyn StorageExtendedEffects> = handler;
23        Self {
24            core,
25            extended: Some(extended),
26        }
27    }
28
29    pub fn new_core(handler: Arc<dyn StorageCoreEffects>) -> Self {
30        Self {
31            core: handler,
32            extended: None,
33        }
34    }
35
36    pub fn new_extended<T: StorageExtendedEffects + 'static>(handler: T) -> Self {
37        let handler = Arc::new(handler);
38        let core: Arc<dyn StorageCoreEffects> = handler.clone();
39        let extended: Arc<dyn StorageExtendedEffects> = handler;
40        Self {
41            core,
42            extended: Some(extended),
43        }
44    }
45}
46
47#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
48#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
49impl RegistrableHandler for StorageHandlerAdapter {
50    async fn execute_operation_bytes(
51        &self,
52        effect_type: EffectType,
53        operation: &str,
54        parameters: &[u8],
55        _ctx: &HandlerContext,
56    ) -> Result<Vec<u8>, HandlerError> {
57        if effect_type != EffectType::Storage {
58            return Err(HandlerError::UnsupportedEffect { effect_type });
59        }
60
61        match operation {
62            "store" => {
63                let params: (String, Vec<u8>) =
64                    deserialize_operation_params(effect_type, operation, parameters)?;
65                self.core.store(&params.0, params.1).await.map_err(|e| {
66                    HandlerError::ExecutionFailed {
67                        source: Box::new(e),
68                    }
69                })?;
70                Ok(Vec::new()) // store returns void
71            }
72            "retrieve" => {
73                let key: String = deserialize_operation_params(effect_type, operation, parameters)?;
74                let result =
75                    self.core
76                        .retrieve(&key)
77                        .await
78                        .map_err(|e| HandlerError::ExecutionFailed {
79                            source: Box::new(e),
80                        })?;
81                serialize_operation_result(effect_type, operation, &result)
82            }
83            "remove" => {
84                let key: String = deserialize_operation_params(effect_type, operation, parameters)?;
85                let result =
86                    self.core
87                        .remove(&key)
88                        .await
89                        .map_err(|e| HandlerError::ExecutionFailed {
90                            source: Box::new(e),
91                        })?;
92                serialize_operation_result(effect_type, operation, &result)
93            }
94            "list_keys" => {
95                let prefix: Option<String> =
96                    deserialize_operation_params(effect_type, operation, parameters)?;
97                let result = self.core.list_keys(prefix.as_deref()).await.map_err(|e| {
98                    HandlerError::ExecutionFailed {
99                        source: Box::new(e),
100                    }
101                })?;
102                serialize_operation_result(effect_type, operation, &result)
103            }
104            "exists" => {
105                let handler =
106                    self.extended
107                        .as_ref()
108                        .ok_or_else(|| HandlerError::UnknownOperation {
109                            effect_type,
110                            operation: operation.to_string(),
111                        })?;
112                let key: String = deserialize_operation_params(effect_type, operation, parameters)?;
113                let result =
114                    handler
115                        .exists(&key)
116                        .await
117                        .map_err(|e| HandlerError::ExecutionFailed {
118                            source: Box::new(e),
119                        })?;
120                serialize_operation_result(effect_type, operation, &result)
121            }
122            "store_batch" => {
123                let handler =
124                    self.extended
125                        .as_ref()
126                        .ok_or_else(|| HandlerError::UnknownOperation {
127                            effect_type,
128                            operation: operation.to_string(),
129                        })?;
130                let pairs: std::collections::HashMap<String, Vec<u8>> =
131                    deserialize_operation_params(effect_type, operation, parameters)?;
132                handler
133                    .store_batch(pairs)
134                    .await
135                    .map_err(|e| HandlerError::ExecutionFailed {
136                        source: Box::new(e),
137                    })?;
138                Ok(Vec::new())
139            }
140            "retrieve_batch" => {
141                let handler =
142                    self.extended
143                        .as_ref()
144                        .ok_or_else(|| HandlerError::UnknownOperation {
145                            effect_type,
146                            operation: operation.to_string(),
147                        })?;
148                let keys: Vec<String> =
149                    deserialize_operation_params(effect_type, operation, parameters)?;
150                let result = handler.retrieve_batch(&keys).await.map_err(|e| {
151                    HandlerError::ExecutionFailed {
152                        source: Box::new(e),
153                    }
154                })?;
155                serialize_operation_result(effect_type, operation, &result)
156            }
157            "clear_all" => {
158                let handler =
159                    self.extended
160                        .as_ref()
161                        .ok_or_else(|| HandlerError::UnknownOperation {
162                            effect_type,
163                            operation: operation.to_string(),
164                        })?;
165                handler
166                    .clear_all()
167                    .await
168                    .map_err(|e| HandlerError::ExecutionFailed {
169                        source: Box::new(e),
170                    })?;
171                Ok(Vec::new())
172            }
173            "stats" => {
174                let handler =
175                    self.extended
176                        .as_ref()
177                        .ok_or_else(|| HandlerError::UnknownOperation {
178                            effect_type,
179                            operation: operation.to_string(),
180                        })?;
181                let result = handler
182                    .stats()
183                    .await
184                    .map_err(|e| HandlerError::ExecutionFailed {
185                        source: Box::new(e),
186                    })?;
187                serialize_operation_result(effect_type, operation, &result)
188            }
189            _ => Err(HandlerError::UnknownOperation {
190                effect_type,
191                operation: operation.to_string(),
192            }),
193        }
194    }
195
196    fn supported_operations(&self, effect_type: EffectType) -> Vec<String> {
197        collect_ops(effect_type, self.extended.is_some())
198    }
199
200    fn supports_effect(&self, effect_type: EffectType) -> bool {
201        effect_type == EffectType::Storage
202    }
203
204    fn execution_mode(&self) -> ExecutionMode {
205        ExecutionMode::Production
206    }
207}
aura_composition/adapters/storage.rs

aura_composition/adapters/
storage.rs
