1use std::fs::File;
6use std::io::{BufRead, BufReader, Seek, SeekFrom};
7use std::ops::Index;
8use std::path::{Path, PathBuf};
9use std::sync::Arc;
10use std::sync::atomic::{self, AtomicBool, AtomicUsize, Ordering};
11
12use bytes::Bytes;
13use embedder_traits::{
14 EmbedderControlId, EmbedderControlResponse, FilePickerRequest, GenericEmbedderProxy,
15 SelectedFile,
16};
17use headers::{ContentLength, ContentRange, ContentType, HeaderMap, HeaderMapExt, Range};
18use log::warn;
19use mime::Mime;
20use net_traits::blob_url_store::{BlobBuf, BlobTokenCommunicator, BlobURLStoreError};
21use net_traits::filemanager_thread::{
22 FileManagerResult, FileManagerThreadError, FileManagerThreadMsg, FileTokenCheck,
23 GetTokenForFileReply, ReadFileProgress, RelativePos,
24};
25use net_traits::response::{Response, ResponseBody};
26use parking_lot::{Mutex, RwLock};
27use profile_traits::generic_callback::GenericCallback;
28use rustc_hash::{FxHashMap, FxHashSet};
29use servo_arc::Arc as ServoArc;
30use servo_base::generic_channel::GenericSender;
31use servo_url::ImmutableOrigin;
32use tokio::io::{AsyncReadExt, AsyncSeekExt};
33use tokio::sync::mpsc::UnboundedSender as TokioSender;
34use tokio::task::yield_now;
35use uuid::Uuid;
36use walkdir::WalkDir;
37
38use crate::async_runtime::spawn_task;
39use crate::embedder::NetToEmbedderMsg;
40use crate::fetch::methods::{CancellationListener, Data, RangeRequestBounds};
41use crate::protocols::get_range_request_bounds;
42
43pub const FILE_CHUNK_SIZE: usize = 32768; struct FileStoreEntry {
47 origin: ImmutableOrigin,
49 file_impl: FileImpl,
51 refs: AtomicUsize,
56 is_valid_url: AtomicBool,
60 outstanding_tokens: FxHashSet<Uuid>,
63}
64
65#[derive(Clone)]
66struct FileMetaData {
67 path: PathBuf,
68 size: u64,
69}
70
71#[derive(Clone)]
73enum FileImpl {
74 MetaDataOnly(FileMetaData),
76 Memory(BlobBuf),
78 Sliced(Uuid, RelativePos),
81}
82
83#[derive(Clone)]
84pub struct FileManager {
85 embedder_proxy: GenericEmbedderProxy<NetToEmbedderMsg>,
86 store: Arc<FileManagerStore>,
87 blob_token_communicator: Arc<Mutex<BlobTokenCommunicator>>,
88}
89
90impl FileManager {
91 pub fn new(
92 embedder_proxy: GenericEmbedderProxy<NetToEmbedderMsg>,
93 blob_token_communicator: Arc<Mutex<BlobTokenCommunicator>>,
94 ) -> FileManager {
95 FileManager {
96 embedder_proxy,
97 store: Arc::new(FileManagerStore::new()),
98 blob_token_communicator,
99 }
100 }
101
102 fn read_file(
103 &self,
104 sender: GenericCallback<FileManagerResult<ReadFileProgress>>,
105 id: Uuid,
106 origin: ImmutableOrigin,
107 ) {
108 let store = self.store.clone();
109 spawn_task(async move {
110 if let Err(e) = store.try_read_file(&sender, id, origin).await {
111 let _ = sender.send(Err(FileManagerThreadError::BlobURLStoreError(e)));
112 }
113 });
114 }
115
116 pub(crate) fn get_token_for_file(&self, file_id: &Uuid, allow_revoked: bool) -> FileTokenCheck {
117 self.store.get_token_for_file(file_id, allow_revoked)
118 }
119
120 pub(crate) fn invalidate_token(&self, token: &FileTokenCheck, file_id: &Uuid) {
121 self.store.invalidate_token(token, file_id);
122 }
123
124 #[expect(clippy::too_many_arguments)]
128 pub(crate) fn fetch_file(
129 &self,
130 done_sender: &mut TokioSender<Data>,
131 cancellation_listener: Arc<CancellationListener>,
132 id: Uuid,
133 file_token: &FileTokenCheck,
134 origin: ImmutableOrigin,
135 response: &mut Response,
136 range: Option<Range>,
137 ) -> Result<(), BlobURLStoreError> {
138 self.fetch_blob_buf(
139 done_sender,
140 cancellation_listener,
141 &id,
142 file_token,
143 &origin,
144 BlobBounds::Unresolved(range),
145 response,
146 )
147 }
148
149 pub fn promote_memory(
150 &self,
151 id: Uuid,
152 blob_buf: BlobBuf,
153 set_valid: bool,
154 origin: ImmutableOrigin,
155 ) {
156 self.store.promote_memory(id, blob_buf, set_valid, origin);
157 }
158
159 pub fn handle(&self, msg: FileManagerThreadMsg) {
161 match msg {
162 FileManagerThreadMsg::SelectFiles(control_id, file_picker_request, response_sender) => {
163 let store = self.store.clone();
164 let embedder = self.embedder_proxy.clone();
165 spawn_task(async move {
166 let embedder_control_msg = store
167 .select_files(control_id, file_picker_request, embedder)
168 .await;
169 response_sender.send(embedder_control_msg).unwrap();
170 });
171 },
172 FileManagerThreadMsg::ReadFile(sender, id, origin) => {
173 self.read_file(sender, id, origin);
174 },
175 FileManagerThreadMsg::PromoteMemory(id, blob_buf, set_valid, origin) => {
176 self.promote_memory(id, blob_buf, set_valid, origin);
177 },
178 FileManagerThreadMsg::AddSlicedURLEntry(id, rel_pos, sender, origin) => {
179 self.store.add_sliced_url_entry(id, rel_pos, sender, origin);
180 },
181 FileManagerThreadMsg::DecRef(id, origin, sender) => {
182 let _ = sender.send(self.store.dec_ref(&id, &origin));
183 },
184 FileManagerThreadMsg::RevokeBlobURL(id, origin, sender) => {
185 let _ = sender.send(self.store.set_blob_url_validity(false, &id, &origin));
186 },
187 FileManagerThreadMsg::ActivateBlobURL(id, sender, origin) => {
188 let _ = sender.send(self.store.set_blob_url_validity(true, &id, &origin));
189 },
190 FileManagerThreadMsg::GetTokenForFile(id, sender) => {
191 let token = match self.get_token_for_file(&id, false) {
192 FileTokenCheck::Required(token) => Some(token),
193 _ => None,
194 };
195
196 let communicator = self.blob_token_communicator.lock();
197 let _ = sender.send(GetTokenForFileReply {
198 token,
199 revoke_sender: communicator.revoke_sender.clone(),
200 refresh_sender: communicator.refresh_token_sender.clone(),
201 });
202 },
203 FileManagerThreadMsg::RevokeTokenForFile(token, id) => {
204 self.invalidate_token(&FileTokenCheck::Required(token), &id);
205 },
206 }
207 }
208
209 pub fn fetch_file_in_chunks(
210 &self,
211 done_sender: &mut TokioSender<Data>,
212 mut reader: impl BufRead + Send + 'static,
213 res_body: ServoArc<Mutex<ResponseBody>>,
214 cancellation_listener: Arc<CancellationListener>,
215 range: RelativePos,
216 ) {
217 let done_sender = done_sender.clone();
218 spawn_task(async move {
219 loop {
220 if cancellation_listener.cancelled() {
221 *res_body.lock() = ResponseBody::Done(vec![]);
222 let _ = done_sender.send(Data::Cancelled);
223 return;
224 }
225 let length = {
226 let buffer = reader.fill_buf().unwrap();
227 let mut buffer_len = buffer.len();
228 if let ResponseBody::Receiving(ref mut body) = *res_body.lock() {
229 let offset = usize::min(
230 {
231 if let Some(end) = range.end {
232 let remaining_bytes =
236 end as usize - range.start as usize - body.len() + 1;
237 if remaining_bytes <= FILE_CHUNK_SIZE {
238 buffer_len = 0;
241 remaining_bytes
242 } else {
243 FILE_CHUNK_SIZE
244 }
245 } else {
246 FILE_CHUNK_SIZE
247 }
248 },
249 buffer.len(),
250 );
251 let chunk = &buffer[0..offset];
252 body.extend_from_slice(chunk);
253 let _ = done_sender.send(Data::Payload(Bytes::copy_from_slice(chunk)));
254 }
255 buffer_len
256 };
257 if length == 0 {
258 let mut body = res_body.lock();
259 let completed_body = match *body {
260 ResponseBody::Receiving(ref mut body) => std::mem::take(body),
261 _ => vec![],
262 };
263 *body = ResponseBody::Done(completed_body);
264 let _ = done_sender.send(Data::Done);
265 break;
266 }
267 reader.consume(length);
268 yield_now().await
269 }
270 });
271 }
272
273 #[expect(clippy::too_many_arguments)]
274 fn fetch_blob_buf(
275 &self,
276 done_sender: &mut TokioSender<Data>,
277 cancellation_listener: Arc<CancellationListener>,
278 id: &Uuid,
279 file_token: &FileTokenCheck,
280 origin_in: &ImmutableOrigin,
281 bounds: BlobBounds,
282 response: &mut Response,
283 ) -> Result<(), BlobURLStoreError> {
284 let file_impl = self.store.get_impl(id, file_token, origin_in)?;
285 let mut is_range_requested = false;
289 match file_impl {
290 FileImpl::Memory(buf) => {
291 let bounds = match bounds {
292 BlobBounds::Unresolved(range) => {
293 if range.is_some() {
294 is_range_requested = true;
295 }
296 get_range_request_bounds(range, buf.size)
297 },
298 BlobBounds::Resolved(bounds) => bounds,
299 };
300 let range = bounds
301 .get_final(Some(buf.size))
302 .map_err(|_| BlobURLStoreError::InvalidRange)?;
303
304 let range = range.to_abs_blob_range(buf.size as usize);
305 let len = range.len() as u64;
306 let content_range = if is_range_requested {
307 ContentRange::bytes(range.start as u64..range.end as u64, buf.size).ok()
308 } else {
309 None
310 };
311
312 set_blob_response_headers(
313 &mut response.headers,
314 len,
315 buf.type_string.parse().unwrap_or(mime::TEXT_PLAIN),
316 content_range,
317 );
318
319 let mut bytes = vec![];
320 bytes.extend_from_slice(buf.bytes.index(range));
321
322 let _ = done_sender.send(Data::Payload(Bytes::copy_from_slice(&bytes)));
323 let _ = done_sender.send(Data::Done);
324
325 Ok(())
326 },
327 FileImpl::MetaDataOnly(metadata) => {
328 let file = File::open(&metadata.path)
335 .map_err(|e| BlobURLStoreError::External(e.to_string()))?;
336 let mut is_range_requested = false;
337 let bounds = match bounds {
338 BlobBounds::Unresolved(range) => {
339 if range.is_some() {
340 is_range_requested = true;
341 }
342 get_range_request_bounds(range, metadata.size)
343 },
344 BlobBounds::Resolved(bounds) => bounds,
345 };
346 let range = bounds
347 .get_final(Some(metadata.size))
348 .map_err(|_| BlobURLStoreError::InvalidRange)?;
349
350 let mut reader = BufReader::with_capacity(FILE_CHUNK_SIZE, file);
351 if reader.seek(SeekFrom::Start(range.start as u64)).is_err() {
352 return Err(BlobURLStoreError::External(
353 "Unexpected method for blob".into(),
354 ));
355 }
356
357 let content_range = if is_range_requested {
358 let abs_range = range.to_abs_blob_range(metadata.size as usize);
359 ContentRange::bytes(abs_range.start as u64..abs_range.end as u64, metadata.size)
360 .ok()
361 } else {
362 None
363 };
364 set_blob_response_headers(
365 &mut response.headers,
366 metadata.size,
367 mime_guess::from_path(metadata.path)
368 .first()
369 .unwrap_or(mime::TEXT_PLAIN),
370 content_range,
371 );
372
373 self.fetch_file_in_chunks(
374 &mut done_sender.clone(),
375 reader,
376 response.body.clone(),
377 cancellation_listener,
378 range,
379 );
380
381 Ok(())
382 },
383 FileImpl::Sliced(parent_id, inner_rel_pos) => {
384 let bounds = RangeRequestBounds::Final(
387 RelativePos::full_range().slice_inner(&inner_rel_pos),
388 );
389 self.fetch_blob_buf(
390 done_sender,
391 cancellation_listener,
392 &parent_id,
393 file_token,
394 origin_in,
395 BlobBounds::Resolved(bounds),
396 response,
397 )
398 },
399 }
400 }
401}
402
403enum BlobBounds {
404 Unresolved(Option<Range>),
405 Resolved(RangeRequestBounds),
406}
407
408struct FileManagerStore {
412 entries: RwLock<FxHashMap<Uuid, FileStoreEntry>>,
413}
414
415impl FileManagerStore {
416 fn new() -> Self {
417 FileManagerStore {
418 entries: RwLock::new(FxHashMap::default()),
419 }
420 }
421
422 fn get_impl(
424 &self,
425 id: &Uuid,
426 file_token: &FileTokenCheck,
427 origin_in: &ImmutableOrigin,
428 ) -> Result<FileImpl, BlobURLStoreError> {
429 match self.entries.read().get(id) {
430 Some(entry) => {
431 if *origin_in != entry.origin {
432 Err(BlobURLStoreError::InvalidOrigin)
433 } else {
434 match file_token {
435 FileTokenCheck::NotRequired => Ok(entry.file_impl.clone()),
436 FileTokenCheck::Required(token) => {
437 if entry.outstanding_tokens.contains(token) {
438 return Ok(entry.file_impl.clone());
439 }
440 Err(BlobURLStoreError::InvalidFileID)
441 },
442 FileTokenCheck::ShouldFail => Err(BlobURLStoreError::InvalidFileID),
443 }
444 }
445 },
446 None => Err(BlobURLStoreError::InvalidFileID),
447 }
448 }
449
450 fn invalidate_token(&self, token: &FileTokenCheck, file_id: &Uuid) {
451 if let FileTokenCheck::Required(token) = token {
452 let mut entries = self.entries.write();
453 if let Some(entry) = entries.get_mut(file_id) {
454 entry.outstanding_tokens.remove(token);
455
456 let zero_refs = entry.refs.load(Ordering::Acquire) == 0;
458
459 let no_outstanding_tokens = entry.outstanding_tokens.is_empty();
461
462 let valid = entry.is_valid_url.load(Ordering::Acquire);
464
465 let do_remove = zero_refs && no_outstanding_tokens && !valid;
467
468 if do_remove {
469 entries.remove(file_id);
470 }
471 }
472 }
473 }
474
475 pub(crate) fn get_token_for_file(&self, file_id: &Uuid, allow_revoked: bool) -> FileTokenCheck {
476 let mut entries = self.entries.write();
477 let parent_id = match entries.get(file_id) {
478 Some(entry) => {
479 if let FileImpl::Sliced(ref parent_id, _) = entry.file_impl {
480 Some(*parent_id)
481 } else {
482 None
483 }
484 },
485 None => return FileTokenCheck::ShouldFail,
486 };
487 let file_id = parent_id.as_ref().unwrap_or(file_id);
488
489 if let Some(entry) = entries.get_mut(file_id) {
490 if !allow_revoked && !entry.is_valid_url.load(Ordering::Acquire) {
491 log::warn!("Refusing to grant token for revoked blob url: {file_id:?}");
492 return FileTokenCheck::ShouldFail;
493 }
494 let token = Uuid::new_v4();
495 entry.outstanding_tokens.insert(token);
496 return FileTokenCheck::Required(token);
497 }
498 FileTokenCheck::ShouldFail
499 }
500
501 fn insert(&self, id: Uuid, entry: FileStoreEntry) {
502 self.entries.write().insert(id, entry);
503 }
504
505 fn remove(&self, id: &Uuid) {
506 self.entries.write().remove(id);
507 }
508
509 fn inc_ref(&self, id: &Uuid, origin_in: &ImmutableOrigin) -> Result<(), BlobURLStoreError> {
510 match self.entries.read().get(id) {
511 Some(entry) => {
512 if entry.origin == *origin_in {
513 entry.refs.fetch_add(1, Ordering::Relaxed);
514 Ok(())
515 } else {
516 Err(BlobURLStoreError::InvalidOrigin)
517 }
518 },
519 None => Err(BlobURLStoreError::InvalidFileID),
520 }
521 }
522
523 fn add_sliced_url_entry(
524 &self,
525 parent_id: Uuid,
526 rel_pos: RelativePos,
527 sender: GenericSender<Result<Uuid, BlobURLStoreError>>,
528 origin_in: ImmutableOrigin,
529 ) {
530 match self.inc_ref(&parent_id, &origin_in) {
531 Ok(_) => {
532 let new_id = Uuid::new_v4();
533 self.insert(
534 new_id,
535 FileStoreEntry {
536 origin: origin_in,
537 file_impl: FileImpl::Sliced(parent_id, rel_pos),
538 refs: AtomicUsize::new(1),
539 is_valid_url: AtomicBool::new(true),
542 outstanding_tokens: Default::default(),
543 },
544 );
545
546 let _ = sender.send(Ok(new_id));
548 },
549 Err(e) => {
550 let _ = sender.send(Err(e));
551 },
552 }
553 }
554
555 async fn select_files(
556 &self,
557 control_id: EmbedderControlId,
558 file_picker_request: FilePickerRequest,
559 embedder_proxy: GenericEmbedderProxy<NetToEmbedderMsg>,
560 ) -> EmbedderControlResponse {
561 let (sender, receiver) = tokio::sync::oneshot::channel();
562
563 let origin = file_picker_request.origin.clone();
564 embedder_proxy.send(NetToEmbedderMsg::SelectFiles(
565 control_id,
566 file_picker_request,
567 sender,
568 ));
569
570 let paths = match receiver.await {
571 Ok(Some(result)) => result,
572 Ok(None) => {
573 return EmbedderControlResponse::FilePicker(None);
574 },
575 Err(error) => {
576 warn!("Failed to receive files from embedder ({:?}).", error);
577 return EmbedderControlResponse::FilePicker(None);
578 },
579 };
580
581 let mut files = Vec::with_capacity(paths.len());
582 let mut failed = false;
583 for path in paths {
584 if let Err(error) = self.create_entries(&path, origin.clone(), &mut files) {
585 failed = true;
586 warn!("Failed to create entries for selected path: {error:?}");
587 }
588 }
589
590 if failed {
597 for file in files.iter() {
598 self.remove(&file.id);
599 }
600 return EmbedderControlResponse::FilePicker(Some(Vec::new()));
601 }
602
603 EmbedderControlResponse::FilePicker(Some(files))
604 }
605
606 fn create_entries(
610 &self,
611 path: &Path,
612 origin: ImmutableOrigin,
613 files: &mut Vec<SelectedFile>,
614 ) -> Result<(), FileManagerThreadError> {
615 if !path.is_dir() {
616 files.push(self.create_entry(path, origin, None)?);
617 return Ok(());
618 }
619 let root_name = path
620 .file_name()
621 .ok_or(FileManagerThreadError::FileSystemError(
622 "Invalid filepath".to_string(),
623 ))?;
624 let entries = walk_directory(path);
625 files.reserve(entries.len());
626 for (path, relative_path) in entries {
627 let relative_path = Path::new(root_name).join(relative_path);
629 let relative_path = relative_path.to_string_lossy().replace('\\', "/");
631 files.push(self.create_entry(&path, origin.clone(), Some(relative_path))?);
632 }
633 Ok(())
634 }
635
636 fn create_entry(
637 &self,
638 file_path: &Path,
639 origin: ImmutableOrigin,
640 relative_path: Option<String>,
641 ) -> Result<SelectedFile, FileManagerThreadError> {
642 use net_traits::filemanager_thread::FileManagerThreadError::FileSystemError;
643
644 let metadata = file_path
645 .metadata()
646 .map_err(|e| FileSystemError(e.to_string()))?;
647 let modified = metadata
648 .modified()
649 .map_err(|e| FileSystemError(e.to_string()))?;
650 let file_size = metadata.len();
651 let file_name = file_path
652 .file_name()
653 .ok_or(FileSystemError("Invalid filepath".to_string()))?;
654
655 let file_impl = FileImpl::MetaDataOnly(FileMetaData {
656 path: file_path.to_path_buf(),
657 size: file_size,
658 });
659
660 let id = Uuid::new_v4();
661
662 self.insert(
663 id,
664 FileStoreEntry {
665 origin,
666 file_impl,
667 refs: AtomicUsize::new(1),
668 is_valid_url: AtomicBool::new(false),
670 outstanding_tokens: Default::default(),
671 },
672 );
673
674 let filename_path = Path::new(file_name);
675 let type_string = match mime_guess::from_path(filename_path).first() {
676 Some(x) => format!("{}", x),
677 None => String::new(),
678 };
679
680 Ok(SelectedFile {
681 id,
682 filename: filename_path.to_path_buf(),
683 modified,
684 size: file_size,
685 type_string,
686 relative_path,
687 })
688 }
689
690 async fn get_blob_buf(
691 &self,
692 sender: &GenericCallback<FileManagerResult<ReadFileProgress>>,
693 id: &Uuid,
694 file_token: &FileTokenCheck,
695 origin_in: &ImmutableOrigin,
696 rel_pos: RelativePos,
697 ) -> Result<(), BlobURLStoreError> {
698 let file_impl = self.get_impl(id, file_token, origin_in)?;
699 match file_impl {
700 FileImpl::Memory(buf) => {
701 let range = rel_pos.to_abs_range(buf.size as usize);
702 let buf = BlobBuf {
703 filename: None,
704 type_string: buf.type_string,
705 size: range.len() as u64,
706 bytes: buf.bytes.index(range).to_vec(),
707 };
708
709 let _ = sender.send(Ok(ReadFileProgress::Meta(buf)));
710 let _ = sender.send(Ok(ReadFileProgress::EOF));
711
712 Ok(())
713 },
714 FileImpl::MetaDataOnly(metadata) => {
715 let opt_filename = metadata
722 .path
723 .file_name()
724 .and_then(|osstr| osstr.to_str())
725 .map(|s| s.to_string());
726
727 let mime = mime_guess::from_path(&metadata.path).first();
728 let range = rel_pos.to_abs_range(metadata.size as usize);
729
730 let mut file = tokio::fs::File::open(&metadata.path)
731 .await
732 .map_err(|e| BlobURLStoreError::External(e.to_string()))?;
733 let seeked_start = file
734 .seek(SeekFrom::Start(range.start as u64))
735 .await
736 .map_err(|e| BlobURLStoreError::External(e.to_string()))?;
737
738 if seeked_start == (range.start as u64) {
739 let type_string = match mime {
740 Some(x) => format!("{}", x),
741 None => String::new(),
742 };
743
744 read_file_in_chunks(sender, file, range.len(), opt_filename, type_string).await;
745 Ok(())
746 } else {
747 Err(BlobURLStoreError::InvalidEntry)
748 }
749 },
750 FileImpl::Sliced(parent_id, inner_rel_pos) => {
751 Box::pin(self.get_blob_buf(
754 sender,
755 &parent_id,
756 file_token,
757 origin_in,
758 rel_pos.slice_inner(&inner_rel_pos),
759 ))
760 .await
761 },
762 }
763 }
764
765 async fn try_read_file(
767 &self,
768 sender: &GenericCallback<FileManagerResult<ReadFileProgress>>,
769 id: Uuid,
770 origin_in: ImmutableOrigin,
771 ) -> Result<(), BlobURLStoreError> {
772 self.get_blob_buf(
773 sender,
774 &id,
775 &FileTokenCheck::NotRequired,
776 &origin_in,
777 RelativePos::full_range(),
778 )
779 .await
780 }
781
782 fn dec_ref(&self, id: &Uuid, origin_in: &ImmutableOrigin) -> Result<(), BlobURLStoreError> {
783 let (do_remove, opt_parent_id) = match self.entries.read().get(id) {
784 Some(entry) => {
785 if entry.origin == *origin_in {
786 let old_refs = entry.refs.fetch_sub(1, Ordering::Release);
787
788 if old_refs > 1 {
789 (false, None)
791 } else {
792 let is_valid = entry.is_valid_url.load(Ordering::Acquire);
795
796 let no_outstanding_tokens = entry.outstanding_tokens.is_empty();
798
799 let do_remove = !is_valid && no_outstanding_tokens;
801
802 if let FileImpl::Sliced(ref parent_id, _) = entry.file_impl {
803 (do_remove, Some(*parent_id))
804 } else {
805 (do_remove, None)
806 }
807 }
808 } else {
809 return Err(BlobURLStoreError::InvalidOrigin);
810 }
811 },
812 None => return Err(BlobURLStoreError::InvalidFileID),
813 };
814
815 if do_remove {
818 atomic::fence(Ordering::Acquire);
819 self.remove(id);
820
821 if let Some(parent_id) = opt_parent_id {
822 return self.dec_ref(&parent_id, origin_in);
823 }
824 }
825
826 Ok(())
827 }
828
829 fn promote_memory(
830 &self,
831 id: Uuid,
832 blob_buf: BlobBuf,
833 set_valid: bool,
834 origin: ImmutableOrigin,
835 ) {
836 self.insert(
837 id,
838 FileStoreEntry {
839 origin,
840 file_impl: FileImpl::Memory(blob_buf),
841 refs: AtomicUsize::new(1),
842 is_valid_url: AtomicBool::new(set_valid),
843 outstanding_tokens: Default::default(),
844 },
845 );
846 }
847
848 fn set_blob_url_validity(
849 &self,
850 validity: bool,
851 id: &Uuid,
852 origin_in: &ImmutableOrigin,
853 ) -> Result<(), BlobURLStoreError> {
854 let (do_remove, opt_parent_id, res) = match self.entries.read().get(id) {
855 Some(entry) => {
856 if entry.origin == *origin_in {
857 entry.is_valid_url.store(validity, Ordering::Release);
858
859 if !validity {
860 let zero_refs = entry.refs.load(Ordering::Acquire) == 0;
864
865 let no_outstanding_tokens = entry.outstanding_tokens.is_empty();
867
868 let do_remove = zero_refs && no_outstanding_tokens;
870
871 if let FileImpl::Sliced(ref parent_id, _) = entry.file_impl {
872 (do_remove, Some(*parent_id), Ok(()))
873 } else {
874 (do_remove, None, Ok(()))
875 }
876 } else {
877 (false, None, Ok(()))
878 }
879 } else {
880 (false, None, Err(BlobURLStoreError::InvalidOrigin))
881 }
882 },
883 None => (false, None, Err(BlobURLStoreError::InvalidFileID)),
884 };
885
886 if do_remove {
887 atomic::fence(Ordering::Acquire);
888 self.remove(id);
889
890 if let Some(parent_id) = opt_parent_id {
891 return self.dec_ref(&parent_id, origin_in);
892 }
893 }
894 res
895 }
896}
897
898async fn read_file_in_chunks(
899 sender: &GenericCallback<FileManagerResult<ReadFileProgress>>,
900 mut file: tokio::fs::File,
901 size: usize,
902 opt_filename: Option<String>,
903 type_string: String,
904) {
905 let mut buf = vec![0; FILE_CHUNK_SIZE];
907 match file.read(&mut buf).await {
908 Ok(n) => {
909 buf.truncate(n);
910 let blob_buf = BlobBuf {
911 filename: opt_filename,
912 type_string,
913 size: size as u64,
914 bytes: buf,
915 };
916 let _ = sender.send(Ok(ReadFileProgress::Meta(blob_buf)));
917 },
918 Err(e) => {
919 let _ = sender.send(Err(FileManagerThreadError::FileSystemError(e.to_string())));
920 return;
921 },
922 }
923
924 loop {
926 let mut buf = vec![0; FILE_CHUNK_SIZE];
927 match file.read(&mut buf).await {
928 Ok(0) => {
929 let _ = sender.send(Ok(ReadFileProgress::EOF));
930 return;
931 },
932 Ok(n) => {
933 buf.truncate(n);
934 let _ = sender.send(Ok(ReadFileProgress::Partial(buf)));
935 },
936 Err(e) => {
937 let _ = sender.send(Err(FileManagerThreadError::FileSystemError(e.to_string())));
938 return;
939 },
940 }
941 }
942}
943
944fn set_blob_response_headers(
945 headers: &mut HeaderMap,
946 content_length: u64,
947 mime: Mime,
948 content_range: Option<ContentRange>,
949) {
950 headers.typed_insert(ContentLength(content_length));
951 if let Some(content_range) = content_range {
952 headers.typed_insert(content_range);
953 }
954 headers.typed_insert(ContentType::from(mime));
955}
956
957fn walk_directory(root: &Path) -> Vec<(PathBuf, PathBuf)> {
959 let mut files = Vec::new();
960 for entry in WalkDir::new(root) {
961 let entry = match entry {
962 Ok(entry) => entry,
963 Err(error) => {
964 warn!("Skipping an unreadable entry while walking a directory: {error}");
965 continue;
966 },
967 };
968 if entry.file_type().is_file() {
969 let relative_path = entry
970 .path()
971 .strip_prefix(root)
972 .expect("walked entries are under root");
973 files.push((entry.path().to_path_buf(), relative_path.to_path_buf()));
974 }
975 }
976 files
977}