file_asset.rs

use crate::io::{
    get_meta_path, AssetReader, AssetReaderError, AssetWriter, AssetWriterError, PathStream,
    Reader, ReaderNotSeekableError, SeekableReader, Writer,
};
use async_fs::{read_dir, File};
#[cfg(not(target_os = "windows"))]
use async_io::Timer;
#[cfg(not(target_os = "windows"))]
use async_lock::{Semaphore, SemaphoreGuard};
use futures_lite::StreamExt;

use alloc::{borrow::ToOwned, boxed::Box};
#[cfg(target_os = "windows")]
use core::marker::PhantomData;
#[cfg(not(target_os = "windows"))]
use core::time::Duration;
#[cfg(not(target_os = "windows"))]
use futures_util::{future, pin_mut};
use std::path::Path;

use super::{FileAssetReader, FileAssetWriter};

impl Reader for File {
    fn seekable(&mut self) -> Result<&mut dyn SeekableReader, ReaderNotSeekableError> {
        Ok(self)
    }
}

// Set to OS default limit / 2
// macos & ios: 256
// linux & android: 1024
#[cfg(any(target_os = "macos", target_os = "ios"))]
static OPEN_FILE_LIMITER: Semaphore = Semaphore::new(128);
#[cfg(not(any(target_os = "macos", target_os = "ios", target_os = "windows")))]
static OPEN_FILE_LIMITER: Semaphore = Semaphore::new(512);

#[cfg(not(target_os = "windows"))]
async fn maybe_get_semaphore<'a>() -> Option<SemaphoreGuard<'a>> {
    let guard_future = OPEN_FILE_LIMITER.acquire();
    let timeout_future = Timer::after(Duration::from_millis(500));
    pin_mut!(guard_future);
    pin_mut!(timeout_future);

    match future::select(guard_future, timeout_future).await {
        future::Either::Left((guard, _)) => Some(guard),
        future::Either::Right((_, _)) => None,
    }
}

struct GuardedFile<'a> {
    file: File,
    #[cfg(not(target_os = "windows"))]
    _guard: Option<SemaphoreGuard<'a>>,
    #[cfg(target_os = "windows")]
    _lifetime: PhantomData<&'a ()>,
}

impl<'a> futures_io::AsyncRead for GuardedFile<'a> {
    fn poll_read(
        mut self: core::pin::Pin<&mut Self>,
        cx: &mut core::task::Context<'_>,
        buf: &mut [u8],
    ) -> core::task::Poll<std::io::Result<usize>> {
        core::pin::Pin::new(&mut self.file).poll_read(cx, buf)
    }
}

impl<'a> Reader for GuardedFile<'a> {
    fn seekable(&mut self) -> Result<&mut dyn SeekableReader, ReaderNotSeekableError> {
        self.file.seekable()
    }
}

impl AssetReader for FileAssetReader {
    async fn read<'a>(&'a self, path: &'a Path) -> Result<impl Reader + 'a, AssetReaderError> {
        #[cfg(not(target_os = "windows"))]
        let _guard = maybe_get_semaphore().await;

        let full_path = self.root_path.join(path);
        File::open(&full_path)
            .await
            .map_err(|e| {
                if e.kind() == std::io::ErrorKind::NotFound {
                    AssetReaderError::NotFound(full_path)
                } else {
                    e.into()
                }
            })
            .map(|file| GuardedFile {
                file,
                #[cfg(not(target_os = "windows"))]
                _guard,
                #[cfg(target_os = "windows")]
                _lifetime: PhantomData,
            })
    }

    async fn read_meta<'a>(&'a self, path: &'a Path) -> Result<impl Reader + 'a, AssetReaderError> {
        #[cfg(not(target_os = "windows"))]
        let _guard = maybe_get_semaphore().await;

        let meta_path = get_meta_path(path);
        let full_path = self.root_path.join(meta_path);
        File::open(&full_path)
            .await
            .map_err(|e| {
                if e.kind() == std::io::ErrorKind::NotFound {
                    AssetReaderError::NotFound(full_path)
                } else {
                    e.into()
                }
            })
            .map(|file| GuardedFile {
                file,
                #[cfg(not(target_os = "windows"))]
                _guard,
                #[cfg(target_os = "windows")]
                _lifetime: PhantomData,
            })
    }

    async fn read_directory<'a>(
        &'a self,
        path: &'a Path,
    ) -> Result<Box<PathStream>, AssetReaderError> {
        let full_path = self.root_path.join(path);
        match read_dir(&full_path).await {
            Ok(read_dir) => {
                let root_path = self.root_path.clone();
                let mapped_stream = read_dir.filter_map(move |f| {
                    f.ok().and_then(|dir_entry| {
                        let path = dir_entry.path();
                        // filter out meta files as they are not considered assets
                        if let Some(ext) = path.extension().and_then(|e| e.to_str())
                            && ext.eq_ignore_ascii_case("meta")
                        {
                            return None;
                        }
                        // filter out hidden files. they are not listed by default but are directly targetable
                        if path
                            .file_name()
                            .and_then(|file_name| file_name.to_str())
                            .map(|file_name| file_name.starts_with('.'))
                            .unwrap_or_default()
                        {
                            return None;
                        }
                        let relative_path = path.strip_prefix(&root_path).unwrap();
                        Some(relative_path.to_owned())
                    })
                });
                let read_dir: Box<PathStream> = Box::new(mapped_stream);
                Ok(read_dir)
            }
            Err(e) => {
                if e.kind() == std::io::ErrorKind::NotFound {
                    Err(AssetReaderError::NotFound(full_path))
                } else {
                    Err(e.into())
                }
            }
        }
    }

    async fn is_directory<'a>(&'a self, path: &'a Path) -> Result<bool, AssetReaderError> {
        let full_path = self.root_path.join(path);
        let metadata = full_path
            .metadata()
            .map_err(|_e| AssetReaderError::NotFound(path.to_owned()))?;
        Ok(metadata.file_type().is_dir())
    }
}

impl AssetWriter for FileAssetWriter {
    async fn write<'a>(&'a self, path: &'a Path) -> Result<Box<Writer>, AssetWriterError> {
        let full_path = self.root_path.join(path);
        if let Some(parent) = full_path.parent() {
            async_fs::create_dir_all(parent).await?;
        }
        let file = File::create(&full_path).await?;
        let writer: Box<Writer> = Box::new(file);
        Ok(writer)
    }

    async fn write_meta<'a>(&'a self, path: &'a Path) -> Result<Box<Writer>, AssetWriterError> {
        let meta_path = get_meta_path(path);
        let full_path = self.root_path.join(meta_path);
        if let Some(parent) = full_path.parent() {
            async_fs::create_dir_all(parent).await?;
        }
        let file = File::create(&full_path).await?;
        let writer: Box<Writer> = Box::new(file);
        Ok(writer)
    }

    async fn remove<'a>(&'a self, path: &'a Path) -> Result<(), AssetWriterError> {
        let full_path = self.root_path.join(path);
        async_fs::remove_file(full_path).await?;
        Ok(())
    }

    async fn remove_meta<'a>(&'a self, path: &'a Path) -> Result<(), AssetWriterError> {
        let meta_path = get_meta_path(path);
        let full_path = self.root_path.join(meta_path);
        async_fs::remove_file(full_path).await?;
        Ok(())
    }

    async fn rename<'a>(
        &'a self,
        old_path: &'a Path,
        new_path: &'a Path,
    ) -> Result<(), AssetWriterError> {
        let full_old_path = self.root_path.join(old_path);
        let full_new_path = self.root_path.join(new_path);
        if let Some(parent) = full_new_path.parent() {
            async_fs::create_dir_all(parent).await?;
        }
        async_fs::rename(full_old_path, full_new_path).await?;
        Ok(())
    }

    async fn rename_meta<'a>(
        &'a self,
        old_path: &'a Path,
        new_path: &'a Path,
    ) -> Result<(), AssetWriterError> {
        let old_meta_path = get_meta_path(old_path);
        let new_meta_path = get_meta_path(new_path);
        let full_old_path = self.root_path.join(old_meta_path);
        let full_new_path = self.root_path.join(new_meta_path);
        if let Some(parent) = full_new_path.parent() {
            async_fs::create_dir_all(parent).await?;
        }
        async_fs::rename(full_old_path, full_new_path).await?;
        Ok(())
    }

    async fn create_directory<'a>(&'a self, path: &'a Path) -> Result<(), AssetWriterError> {
        let full_path = self.root_path.join(path);
        async_fs::create_dir_all(full_path).await?;
        Ok(())
    }

    async fn remove_directory<'a>(&'a self, path: &'a Path) -> Result<(), AssetWriterError> {
        let full_path = self.root_path.join(path);
        async_fs::remove_dir_all(full_path).await?;
        Ok(())
    }

    async fn remove_empty_directory<'a>(&'a self, path: &'a Path) -> Result<(), AssetWriterError> {
        let full_path = self.root_path.join(path);
        async_fs::remove_dir(full_path).await?;
        Ok(())
    }

    async fn remove_assets_in_directory<'a>(
        &'a self,
        path: &'a Path,
    ) -> Result<(), AssetWriterError> {
        let full_path = self.root_path.join(path);
        async_fs::remove_dir_all(&full_path).await?;
        async_fs::create_dir_all(&full_path).await?;
        Ok(())
    }
}