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 5683 : fn default() -> Self {
15 5683 : match super::io_engine::get() {
16 0 : IoEngine::NotSet => panic!("io engine not set"),
17 2840 : IoEngine::StdFs => Self::StdFs(std::fs::OpenOptions::new()),
18 : #[cfg(target_os = "linux")]
19 : IoEngine::TokioEpollUring => {
20 2843 : Self::TokioEpollUring(tokio_epoll_uring::ops::open_at::OpenOptions::new())
21 : }
22 : }
23 5683 : }
24 : }
25 :
26 : impl OpenOptions {
27 5683 : pub fn new() -> OpenOptions {
28 5683 : Self::default()
29 5683 : }
30 :
31 4102 : pub fn read(&mut self, read: bool) -> &mut OpenOptions {
32 4102 : match self {
33 2051 : OpenOptions::StdFs(x) => {
34 2051 : let _ = x.read(read);
35 2051 : }
36 : #[cfg(target_os = "linux")]
37 2051 : OpenOptions::TokioEpollUring(x) => {
38 2051 : let _ = x.read(read);
39 2051 : }
40 : }
41 4102 : self
42 4102 : }
43 :
44 2825 : pub fn write(&mut self, write: bool) -> &mut OpenOptions {
45 2825 : match self {
46 1411 : OpenOptions::StdFs(x) => {
47 1411 : let _ = x.write(write);
48 1411 : }
49 : #[cfg(target_os = "linux")]
50 1414 : OpenOptions::TokioEpollUring(x) => {
51 1414 : let _ = x.write(write);
52 1414 : }
53 : }
54 2825 : self
55 2825 : }
56 :
57 8070 : pub fn create(&mut self, create: bool) -> &mut OpenOptions {
58 8070 : match self {
59 4032 : OpenOptions::StdFs(x) => {
60 4032 : let _ = x.create(create);
61 4032 : }
62 : #[cfg(target_os = "linux")]
63 4038 : OpenOptions::TokioEpollUring(x) => {
64 4038 : let _ = x.create(create);
65 4038 : }
66 : }
67 8070 : self
68 8070 : }
69 :
70 5709 : pub fn create_new(&mut self, create_new: bool) -> &mut OpenOptions {
71 5709 : match self {
72 2853 : OpenOptions::StdFs(x) => {
73 2853 : let _ = x.create_new(create_new);
74 2853 : }
75 : #[cfg(target_os = "linux")]
76 2856 : OpenOptions::TokioEpollUring(x) => {
77 2856 : let _ = x.create_new(create_new);
78 2856 : }
79 : }
80 5709 : self
81 5709 : }
82 :
83 6830 : pub fn truncate(&mut self, truncate: bool) -> &mut OpenOptions {
84 6830 : match self {
85 3412 : OpenOptions::StdFs(x) => {
86 3412 : let _ = x.truncate(truncate);
87 3412 : }
88 : #[cfg(target_os = "linux")]
89 3418 : OpenOptions::TokioEpollUring(x) => {
90 3418 : let _ = x.truncate(truncate);
91 3418 : }
92 : }
93 6830 : self
94 6830 : }
95 :
96 194977 : pub(in crate::virtual_file) async fn open(&self, path: &Path) -> std::io::Result<OwnedFd> {
97 194977 : match self {
98 99594 : OpenOptions::StdFs(x) => x.open(path).map(|file| file.into()),
99 : #[cfg(target_os = "linux")]
100 95383 : OpenOptions::TokioEpollUring(x) => {
101 95383 : let system = super::io_engine::tokio_epoll_uring_ext::thread_local_system().await;
102 95387 : 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 95383 : })
108 : }
109 : }
110 194977 : }
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 : }
|