Skip to main content

coven_storage/
memory_requests.rs

1use super::memory_upload::MemoryStart;
2use super::*;
3
4/// Each attempted native call in the in-memory provider, before fault injection.
5/// This provider has one page per listing and no implicit metadata lookups.
6#[derive(Clone, Debug, PartialEq, Eq)]
7pub enum MemoryRequest {
8    /// Read a whole object or an explicit byte range (including missing paths).
9    Read(ObjectPath, Option<ByteRange>),
10    /// Enumerate one prefix in one native call.
11    List(ObjectPrefix),
12    /// Publish an immutable object.
13    Create(ObjectPath),
14    /// Replace an object.
15    Replace(ObjectPath),
16    /// Query exact metadata.
17    Status(ObjectPath),
18    /// Delete an object.
19    Delete(ObjectPath),
20    /// Account, permission or multipart control/part call.
21    Other(&'static str),
22}
23
24impl MemoryRequest {
25    /// Whether the request changes what storage holds.
26    fn writes(&self) -> bool {
27        match self {
28            Self::Create(_) | Self::Replace(_) | Self::Delete(_) => true,
29            Self::Read(..) | Self::List(_) | Self::Status(_) => false,
30            Self::Other(call) => matches!(
31                *call,
32                "create_location_marker"
33                    | "begin_upload"
34                    | "initiate_upload"
35                    | "upload_part"
36                    | "finish_upload"
37                    | "abort_upload"
38                    | "end_left_upload"
39            ),
40        }
41    }
42}
43
44/// Which requests signed with an S3 key storage refuses
45/// (`MemoryStorage::refuse_s3_key`).
46#[derive(Clone, Copy, Debug, PartialEq, Eq)]
47pub enum KeyRefusal {
48    /// Every request, with `Authentication` in a 403, as for a key the
49    /// person deleted or mistyped.
50    Every,
51    /// Every write, with `PermissionDenied` in a 403, as for a key that may
52    /// only read; its reads go through.
53    Writes,
54}
55
56impl MemoryStorage {
57    /// Refuse the requests `refusal` names when they are signed with the S3
58    /// key `access_key_id`, from now on and on every connection, as S3
59    /// storage refuses a key.
60    pub async fn refuse_s3_key(&self, access_key_id: &str, refusal: KeyRefusal) {
61        self.provider.state.lock().await.refused_s3_keys.insert(access_key_id.into(), refusal);
62    }
63
64    /// Attempted calls on this connection; `for_device` starts a separate trace.
65    pub fn request_trace(&self) -> Vec<MemoryRequest> {
66        self.provider.request_trace.lock().expect("request trace poisoned").clone()
67    }
68}
69
70impl MemoryStorage {
71    /// Hold one listing's reply after taking its snapshot. The test is notified
72    /// when the result is fixed, and can mutate remote state before releasing it.
73    pub async fn hold_next_listing(
74        &self,
75        prefix: ObjectPrefix,
76        listed: tokio::sync::oneshot::Sender<()>,
77        resume: tokio::sync::oneshot::Receiver<()>,
78    ) {
79        let mut state = self.provider.state.lock().await;
80        assert!(state.held_listing.is_none(), "a listing is already held");
81        state.held_listing = Some(HeldRequest { prefix, listed, resume });
82    }
83    /// Hold the next request, whatever it is, once it is recorded: tell
84    /// `started`, then wait for `resume`.
85    pub async fn hold_next_request(
86        &self,
87        started: tokio::sync::oneshot::Sender<()>,
88        resume: tokio::sync::oneshot::Receiver<()>,
89    ) {
90        let mut state = self.provider.state.lock().await;
91        assert!(state.held_request.is_none(), "a request is already held");
92        state.held_request = Some(HeldNext { request: None, started, resume });
93    }
94    /// Hold the next request that is `request` once it is recorded, as
95    /// [`Self::hold_next_request`] does; every other request goes through.
96    pub async fn hold_next_request_of(
97        &self,
98        request: MemoryRequest,
99        started: tokio::sync::oneshot::Sender<()>,
100        resume: tokio::sync::oneshot::Receiver<()>,
101    ) {
102        let mut state = self.provider.state.lock().await;
103        assert!(state.held_request.is_none(), "a request is already held");
104        state.held_request = Some(HeldNext { request: Some(request), started, resume });
105    }
106    /// Hold a single-request creation before publication, notifying its observer.
107    pub async fn hold_next_creation(
108        &self,
109        prefix: ObjectPrefix,
110        started: tokio::sync::oneshot::Sender<()>,
111        resume: tokio::sync::oneshot::Receiver<()>,
112    ) {
113        let mut state = self.provider.state.lock().await;
114        assert!(state.held_creation.is_none(), "a creation is already held");
115        state.held_creation = Some(HeldRequest { prefix, listed: started, resume });
116    }
117}
118
119/// A provider permission request held before changing its durable grant.
120pub(super) struct HeldAccess {
121    account: String,
122    grant: bool,
123    started: tokio::sync::oneshot::Sender<()>,
124    resume: tokio::sync::oneshot::Receiver<()>,
125}
126
127impl MemoryStorage {
128    /// Hold one account request before it reaches the provider's grant state.
129    pub async fn hold_next_access(
130        &self,
131        account: &str,
132        grant: bool,
133        started: tokio::sync::oneshot::Sender<()>,
134        resume: tokio::sync::oneshot::Receiver<()>,
135    ) {
136        let mut state = self.provider.state.lock().await;
137        assert!(state.held_access.is_none(), "an access request is already held");
138        state.held_access = Some(HeldAccess { account: account.into(), grant, started, resume });
139    }
140}
141
142impl MemoryProvider {
143    #[expect(
144        clippy::let_underscore_must_use,
145        reason = "a send fails only when the receiver is gone, which this names"
146    )]
147    pub(super) async fn hold_access(&self, account: &str, grant: bool) {
148        let held = {
149            let mut state = self.state.lock().await;
150            if state.held_access.as_ref().is_some_and(|h| h.account == account && h.grant == grant)
151            {
152                state.held_access.take()
153            } else {
154                None
155            }
156        };
157        if let Some(held) = held {
158            let _ = held.started.send(());
159            held.resume.await.expect("held access request was not released");
160        }
161    }
162}
163
164impl MemoryProvider {
165    pub(super) async fn before_request(&self, request: MemoryRequest) -> Result<(), StorageError> {
166        self.request_going(request, None).await
167    }
168    /// Record `request`, hold it if a test asked, then answer it as `Faults`
169    /// say. A planned session's `start` is checked against the publication
170    /// gate past the hold, as S3 checks it as the request goes out, and goes
171    /// out once that check passes (Appendix E.10).
172    async fn request_going(
173        &self,
174        request: MemoryRequest,
175        start: Option<MemoryStart<'_>>,
176    ) -> Result<(), StorageError> {
177        let active = self.active_requests.fetch_add(1, std::sync::atomic::Ordering::SeqCst) + 1;
178        let _request = ActiveMemoryRequest(&self.active_requests);
179        self.peak_requests.fetch_max(active, std::sync::atomic::Ordering::SeqCst);
180        self.request_trace.lock().expect("request trace poisoned").push(request.clone());
181        self.requests.send_modify(|count| *count += 1);
182        let held = {
183            let mut state = self.state.lock().await;
184            match &state.held_request {
185                Some(held) if held.request.as_ref().is_none_or(|kind| *kind == request) => {
186                    state.held_request.take()
187                }
188                _ => None,
189            }
190        };
191        if let Some(held) = held {
192            held.started
193                .send(())
194                .map_err(|()| StorageFailure::Protocol.with_source("request observer dropped"))?;
195            held.resume.await.map_err(|closed| StorageFailure::Protocol.with_source(closed))?;
196        }
197        if let Some(start) = start {
198            start.go()?;
199        }
200        if !self.online.load(std::sync::atomic::Ordering::SeqCst) {
201            return Err(StorageFailure::Network
202                .with_source(std::io::Error::from(std::io::ErrorKind::NotConnected)));
203        }
204        let (delay, failure, barrier) = {
205            let mut state = self.state.lock().await;
206            if std::mem::replace(&mut state.faults.expire_uploads, false) {
207                state.uploads.clear();
208            }
209            let failure = if state.faults.fail_next > 0 {
210                state.faults.fail_next -= 1;
211                Some((state.faults.failure, state.faults.response, state.faults.retry_after))
212            } else {
213                None
214            };
215            let (barrier, gate) = match &request {
216                MemoryRequest::Create(_) => {
217                    (state.creation_barrier.clone(), state.creation_gate.clone())
218                }
219                MemoryRequest::Read(..) => (None, state.read_gate.clone()),
220                _ => (None, None),
221            };
222            (state.faults.delay, failure, (barrier, gate))
223        };
224        let (barrier, gate) = barrier;
225        if let Some(barrier) = barrier {
226            barrier.wait().await;
227        }
228        if let Some(gate) = gate {
229            gate.acquire()
230                .await
231                .map_err(|closed| StorageFailure::Protocol.with_source(closed))?
232                .forget();
233        }
234        if !delay.is_zero() {
235            self.clock.deadline(delay).await;
236        }
237        match failure {
238            Some(failure) => Err(self.injected(failure)),
239            None => {
240                self.refuse_key(&request).await?;
241                self.authorize(request).await
242            }
243        }
244    }
245    /// Refuse `request` when storage refuses the S3 key this connection
246    /// signs with, as `KeyRefusal` says.
247    async fn refuse_key(&self, request: &MemoryRequest) -> Result<(), StorageError> {
248        let Some(key) = self.s3_key.lock().await.as_ref().map(|key| key.access_key_id.clone())
249        else {
250            return Ok(());
251        };
252        let failure = match self.state.lock().await.refused_s3_keys.get(&key) {
253            Some(KeyRefusal::Every) => StorageFailure::Authentication,
254            Some(KeyRefusal::Writes) if request.writes() => StorageFailure::PermissionDenied,
255            Some(KeyRefusal::Writes) | None => return Ok(()),
256        };
257        Err(crate::providers::ProviderResponse::injected(
258            self.config.provider(),
259            failure,
260            403,
261            None,
262        ))
263    }
264    /// An injected failure, as `Faults` describes it: no response without a
265    /// status or a `Retry-After`, else a response, a 429 unless it names
266    /// another status.
267    pub(super) fn injected(
268        &self,
269        (failure, status, retry_after): (StorageFailure, Option<u16>, Option<u64>),
270    ) -> StorageError {
271        match (status, retry_after) {
272            (None, None) => StorageError::Failure(failure),
273            (status, retry_after) => crate::providers::ProviderResponse::injected(
274                self.config.provider(),
275                failure,
276                status.unwrap_or(429),
277                retry_after,
278            ),
279        }
280    }
281    /// Send the held token; a rejected one is replaced once and the request
282    /// retried once, counted as a second request.
283    async fn authorize(&self, request: MemoryRequest) -> Result<(), StorageError> {
284        let Some(held) = self.tokens.lock().await.clone() else {
285            return Ok(());
286        };
287        let rejected = |tokens: &OAuthTokens| {
288            let token = tokens.access_token.as_str().to_owned();
289            async move { self.state.lock().await.rejected_tokens.contains(&token) }
290        };
291        let used = held.current().await;
292        if !rejected(&used).await {
293            return Ok(());
294        }
295        let replacement = held.rejected(&used).await?;
296        self.request_trace.lock().expect("request trace poisoned").push(request);
297        self.requests.send_modify(|count| *count += 1);
298        if rejected(&replacement).await {
299            return Err(StorageFailure::Authentication.into());
300        }
301        Ok(())
302    }
303    pub(super) async fn before(&self, request: MemoryRequest) -> Result<(), StorageError> {
304        self.before_going(request, None).await
305    }
306    /// [`Self::before`], for a planned session's `start` (`request_going`).
307    pub(super) async fn before_going(
308        &self,
309        request: MemoryRequest,
310        start: Option<MemoryStart<'_>>,
311    ) -> Result<(), StorageError> {
312        self.request_going(request, start).await?;
313        if let Account::Recipient(email) = &self.account {
314            let state = self.state.lock().await;
315            let allowed = match state.accounts.get(email) {
316                Some(AccountAccess::Joined) => true,
317                Some(AccountAccess::Invited) | None => false,
318            };
319            if !allowed {
320                return Err(StorageFailure::PermissionDenied.into());
321            }
322        }
323        Ok(())
324    }
325}
326
327struct ActiveMemoryRequest<'a>(&'a std::sync::atomic::AtomicUsize);
328impl Drop for ActiveMemoryRequest<'_> {
329    fn drop(&mut self) {
330        self.0.fetch_sub(1, std::sync::atomic::Ordering::SeqCst);
331    }
332}