1use super::memory_upload::MemoryStart;
2use super::*;
3
4#[derive(Clone, Debug, PartialEq, Eq)]
7pub enum MemoryRequest {
8 Read(ObjectPath, Option<ByteRange>),
10 List(ObjectPrefix),
12 Create(ObjectPath),
14 Replace(ObjectPath),
16 Status(ObjectPath),
18 Delete(ObjectPath),
20 Other(&'static str),
22}
23
24impl MemoryRequest {
25 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#[derive(Clone, Copy, Debug, PartialEq, Eq)]
47pub enum KeyRefusal {
48 Every,
51 Writes,
54}
55
56impl MemoryStorage {
57 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 pub fn request_trace(&self) -> Vec<MemoryRequest> {
66 self.provider.request_trace.lock().expect("request trace poisoned").clone()
67 }
68}
69
70impl MemoryStorage {
71 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 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 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 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
119pub(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 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 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 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 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 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 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}