arcbox-fs 0.6.3

//! Error types for the filesystem service.

use arcbox_error::CommonError;
use thiserror::Error;

/// Result type alias for filesystem operations.
pub type Result<T> = std::result::Result<T, FsError>;

/// Errors that can occur during filesystem operations.
#[derive(Debug, Error)]
pub enum FsError {
    /// Common errors shared across `ArcBox` crates.
    #[error(transparent)]
    Common(#[from] CommonError),

    /// Invalid path.
    #[error("invalid path: {0}")]
    InvalidPath(String),

    /// Operation not supported.
    #[error("operation not supported: {0}")]
    NotSupported(String),

    /// FUSE protocol error.
    #[error("FUSE error: {0}")]
    Fuse(String),

    /// Cache error.
    #[error("cache error: {0}")]
    Cache(String),

    /// Invalid file handle.
    #[error("invalid file handle: {0}")]
    InvalidHandle(u64),
}

impl From<std::io::Error> for FsError {
    fn from(err: std::io::Error) -> Self {
        Self::Common(CommonError::from(err))
    }
}

impl FsError {
    /// Creates an I/O error.
    #[must_use]
    pub fn io(err: std::io::Error) -> Self {
        Self::Common(CommonError::Io(err))
    }

    /// Creates a not found error.
    #[must_use]
    pub fn not_found(path: impl Into<String>) -> Self {
        Self::Common(CommonError::not_found(path))
    }

    /// Creates a permission denied error.
    #[must_use]
    pub fn permission_denied(path: impl Into<String>) -> Self {
        Self::Common(CommonError::permission_denied(path))
    }

    /// Returns true if this is a not found error.
    #[must_use]
    pub fn is_not_found(&self) -> bool {
        matches!(self, Self::Common(CommonError::NotFound(_)))
    }

    /// Converts the error to a POSIX errno.
    #[must_use]
    pub fn to_errno(&self) -> i32 {
        match self {
            Self::Common(e) => Self::common_to_errno(e),
            Self::InvalidPath(_) => libc::EINVAL,
            Self::NotSupported(_) => libc::ENOSYS,
            Self::Fuse(_) | Self::Cache(_) => libc::EIO,
            Self::InvalidHandle(_) => libc::EBADF,
        }
    }

    /// Converts a CommonError to a Linux-compatible POSIX errno.
    fn common_to_errno(err: &CommonError) -> i32 {
        match err {
            CommonError::Io(e) => {
                let raw = e.raw_os_error().unwrap_or(libc::EIO);
                Self::host_errno_to_linux(raw)
            }
            CommonError::NotFound(_) => libc::ENOENT,
            CommonError::PermissionDenied(_) => libc::EACCES,
            CommonError::AlreadyExists(_) => libc::EEXIST,
            CommonError::Config(_)
            | CommonError::InvalidState(_)
            | CommonError::Timeout(_)
            | CommonError::Internal(_) => libc::EIO,
        }
    }

    /// Translates a host (macOS) errno to a Linux errno.
    ///
    /// macOS and Linux share many POSIX errno values (1-34) but diverge
    /// for platform-specific codes. The FUSE response must use Linux
    /// errno numbers because the guest kernel interprets them directly.
    #[cfg(target_os = "macos")]
    fn host_errno_to_linux(errno: i32) -> i32 {
        // macOS errno constants that differ from Linux:
        // macOS ENOATTR (93) → Linux ENODATA (61)
        // macOS ENOPOLICY (103) → Linux EIO
        // macOS EQFULL (106) → Linux EIO
        const MACOS_ENOATTR: i32 = 93;
        const LINUX_ENODATA: i32 = 61;

        match errno {
            MACOS_ENOATTR => LINUX_ENODATA,
            _ => errno,
        }
    }

    #[cfg(not(target_os = "macos"))]
    fn host_errno_to_linux(errno: i32) -> i32 {
        errno
    }
}