Line data    Source code

       1              : //! Enum-dispatch to the `OpenOptions` type of the respective [`super::IoEngineKind`];
       2              : 
       3              : use std::os::fd::OwnedFd;
       4              : use std::path::Path;
       5              : 
       6              : use super::io_engine::IoEngine;
       7              : 
       8              : #[derive(Debug, Clone)]
       9              : pub enum OpenOptions {
      10              :     StdFs(std::fs::OpenOptions),
      11              :     #[cfg(target_os = "linux")]
      12              :     TokioEpollUring(tokio_epoll_uring::ops::open_at::OpenOptions),
      13              : }
      14              : 
      15              : impl Default for OpenOptions {
      16        38358 :     fn default() -> Self {
      17        38358 :         match super::io_engine::get() {
      18            0 :             IoEngine::NotSet => panic!("io engine not set"),
      19        19158 :             IoEngine::StdFs => Self::StdFs(std::fs::OpenOptions::new()),
      20              :             #[cfg(target_os = "linux")]
      21              :             IoEngine::TokioEpollUring => {
      22        19200 :                 Self::TokioEpollUring(tokio_epoll_uring::ops::open_at::OpenOptions::new())
      23              :             }
      24              :         }
      25        38358 :     }
      26              : }
      27              : 
      28              : impl OpenOptions {
      29        38358 :     pub fn new() -> OpenOptions {
      30        38358 :         Self::default()
      31        38358 :     }
      32              : 
      33        25452 :     pub fn read(&mut self, read: bool) -> &mut OpenOptions {
      34        25452 :         match self {
      35        12726 :             OpenOptions::StdFs(x) => {
      36        12726 :                 let _ = x.read(read);
      37        12726 :             }
      38              :             #[cfg(target_os = "linux")]
      39        12726 :             OpenOptions::TokioEpollUring(x) => {
      40        12726 :                 let _ = x.read(read);
      41        12726 :             }
      42              :         }
      43        25452 :         self
      44        25452 :     }
      45              : 
      46        20886 :     pub fn write(&mut self, write: bool) -> &mut OpenOptions {
      47        20886 :         match self {
      48        10422 :             OpenOptions::StdFs(x) => {
      49        10422 :                 let _ = x.write(write);
      50        10422 :             }
      51              :             #[cfg(target_os = "linux")]
      52        10464 :             OpenOptions::TokioEpollUring(x) => {
      53        10464 :                 let _ = x.write(write);
      54        10464 :             }
      55              :         }
      56        20886 :         self
      57        20886 :     }
      58              : 
      59        54264 :     pub fn create(&mut self, create: bool) -> &mut OpenOptions {
      60        54264 :         match self {
      61        27090 :             OpenOptions::StdFs(x) => {
      62        27090 :                 let _ = x.create(create);
      63        27090 :             }
      64              :             #[cfg(target_os = "linux")]
      65        27174 :             OpenOptions::TokioEpollUring(x) => {
      66        27174 :                 let _ = x.create(create);
      67        27174 :             }
      68              :         }
      69        54264 :         self
      70        54264 :     }
      71              : 
      72        40866 :     pub fn create_new(&mut self, create_new: bool) -> &mut OpenOptions {
      73        40866 :         match self {
      74        20412 :             OpenOptions::StdFs(x) => {
      75        20412 :                 let _ = x.create_new(create_new);
      76        20412 :             }
      77              :             #[cfg(target_os = "linux")]
      78        20454 :             OpenOptions::TokioEpollUring(x) => {
      79        20454 :                 let _ = x.create_new(create_new);
      80        20454 :             }
      81              :         }
      82        40866 :         self
      83        40866 :     }
      84              : 
      85        46308 :     pub fn truncate(&mut self, truncate: bool) -> &mut OpenOptions {
      86        46308 :         match self {
      87        23112 :             OpenOptions::StdFs(x) => {
      88        23112 :                 let _ = x.truncate(truncate);
      89        23112 :             }
      90              :             #[cfg(target_os = "linux")]
      91        23196 :             OpenOptions::TokioEpollUring(x) => {
      92        23196 :                 let _ = x.truncate(truncate);
      93        23196 :             }
      94              :         }
      95        46308 :         self
      96        46308 :     }
      97              : 
      98      1178426 :     pub(in crate::virtual_file) async fn open(&self, path: &Path) -> std::io::Result<OwnedFd> {
      99      1178426 :         match self {
     100       594974 :             OpenOptions::StdFs(x) => x.open(path).map(|file| file.into()),
     101              :             #[cfg(target_os = "linux")]
     102       583452 :             OpenOptions::TokioEpollUring(x) => {
     103       583452 :                 let system = super::io_engine::tokio_epoll_uring_ext::thread_local_system().await;
     104       583452 :                 system.open(path, x).await.map_err(|e| match e {
     105            0 :                     tokio_epoll_uring::Error::Op(e) => e,
     106            0 :                     tokio_epoll_uring::Error::System(system) => {
     107            0 :                         std::io::Error::new(std::io::ErrorKind::Other, system)
     108              :                     }
     109       583452 :                 })
     110              :             }
     111              :         }
     112      1178426 :     }
     113              : }
     114              : 
     115              : impl std::os::unix::prelude::OpenOptionsExt for OpenOptions {
     116            0 :     fn mode(&mut self, mode: u32) -> &mut OpenOptions {
     117            0 :         match self {
     118            0 :             OpenOptions::StdFs(x) => {
     119            0 :                 let _ = x.mode(mode);
     120            0 :             }
     121              :             #[cfg(target_os = "linux")]
     122            0 :             OpenOptions::TokioEpollUring(x) => {
     123            0 :                 let _ = x.mode(mode);
     124            0 :             }
     125              :         }
     126            0 :         self
     127            0 :     }
     128              : 
     129            0 :     fn custom_flags(&mut self, flags: i32) -> &mut OpenOptions {
     130            0 :         match self {
     131            0 :             OpenOptions::StdFs(x) => {
     132            0 :                 let _ = x.custom_flags(flags);
     133            0 :             }
     134              :             #[cfg(target_os = "linux")]
     135            0 :             OpenOptions::TokioEpollUring(x) => {
     136            0 :                 let _ = x.custom_flags(flags);
     137            0 :             }
     138              :         }
     139            0 :         self
     140            0 :     }
     141              : }