Line data    Source code

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