async-fd-lock 0.2.0

Advisory cross-platform file locks using file descriptors with async support by spawning blocking tasks.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use async_fd_lock::{
    AsOpenFile, LockError, LockRead, LockReadResult, LockWrite, LockWriteResult,
};
use async_trait::async_trait;
use std::io::ErrorKind;
use std::path::Path;
use std::time::Duration;
use tokio::fs::File;
use tokio::time;
use tokio::time::error::Elapsed;

pub mod blocking {
    pub use async_fd_lock::blocking::*;
    pub use std::fs::File;
    use std::path::Path;

    pub async fn file_create(path: impl AsRef<Path>) -> std::io::Result<File> {
        File::create(path)
    }

    pub async fn file_open(path: impl AsRef<Path>) -> std::io::Result<File> {
        File::open(path)
    }
}

pub async fn file_create(path: impl AsRef<Path>) -> std::io::Result<File> {
    File::create(path).await
}

pub async fn file_open(path: impl AsRef<Path>) -> std::io::Result<File> {
    File::open(path).await
}

#[async_trait]
pub trait LockReadExt: AsOpenFile {
    async fn try_lock_read_async(self) -> LockReadResult<Self>
    where
        Self: Sized + Send + Sync + 'static;
}

#[async_trait]
pub trait LockWriteExt: AsOpenFile {
    async fn try_lock_write_async(self) -> LockWriteResult<Self>
    where
        Self: Sized + Send + Sync + 'static;
}

#[async_trait]
impl LockReadExt for std::fs::File {
    async fn try_lock_read_async(self) -> LockReadResult<Self>
    where
        Self: Sized + Send + Sync + 'static,
    {
        blocking::LockRead::try_lock_read(self)
    }
}

#[async_trait]
impl LockWriteExt for std::fs::File {
    async fn try_lock_write_async(self) -> LockWriteResult<Self>
    where
        Self: Sized + Send + Sync + 'static,
    {
        blocking::LockWrite::try_lock_write(self)
    }
}

#[async_trait]
impl LockReadExt for tokio::fs::File {
    async fn try_lock_read_async(self) -> LockReadResult<Self>
    where
        Self: Sized + Send + Sync + 'static,
    {
        LockRead::try_lock_read(self).await
    }
}

#[async_trait]
impl LockWriteExt for tokio::fs::File {
    async fn try_lock_write_async(self) -> LockWriteResult<Self>
    where
        Self: Sized + Send + Sync + 'static,
    {
        LockWrite::try_lock_write(self).await
    }
}

#[async_trait]
pub trait AsyncTryClone {
    async fn async_try_clone(&self) -> std::io::Result<Self>
    where
        Self: Sized;
}

#[async_trait]
impl AsyncTryClone for std::fs::File {
    async fn async_try_clone(&self) -> std::io::Result<Self>
    where
        Self: Sized,
    {
        self.try_clone()
    }
}

#[async_trait]
impl AsyncTryClone for tokio::fs::File {
    async fn async_try_clone(&self) -> std::io::Result<Self>
    where
        Self: Sized,
    {
        self.try_clone().await
    }
}

#[async_trait]
pub trait AsOpenFileExt: AsOpenFile {
    async fn timeout_lock_read_async(self) -> LockReadResult<Self>
    where
        Self: Sized + Send + Sync + 'static;
    async fn timeout_lock_write_async(self) -> LockWriteResult<Self>
    where
        Self: Sized + Send + Sync + 'static;
}

const TIMEOUT: Duration = Duration::from_millis(1000);

#[async_trait]
impl<T> AsOpenFileExt for T
where
    T: AsOpenFile + LockRead + LockWrite + AsyncTryClone,
{
    async fn timeout_lock_read_async(self) -> LockReadResult<Self>
    where
        T: Sized + Send + Sync + 'static,
    {
        let clone = match self.async_try_clone().await {
            Ok(clone) => clone,
            Err(error) => return Err(LockError::new(self, error)),
        };
        time::timeout(TIMEOUT, self.lock_read())
            .await
            .map_err(move |_: Elapsed| LockError::new(clone, ErrorKind::WouldBlock.into()))
            .and_then(std::convert::identity)
    }

    async fn timeout_lock_write_async(self) -> LockWriteResult<Self>
    where
        T: Sized + Send + Sync + 'static,
    {
        let clone = match self.async_try_clone().await {
            Ok(clone) => clone,
            Err(error) => return Err(LockError::new(self, error)),
        };
        time::timeout(TIMEOUT, self.lock_write())
            .await
            .map_err(move |_: Elapsed| LockError::new(clone, ErrorKind::WouldBlock.into()))
            .and_then(std::convert::identity)
    }
}