smb 0.11.2

A Pure Rust SMB Client implementation
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

//! This is a helper module that allows easy access and usage of
//! Async/Multi-threaded features in the library, according to the
//! features enabled.
#[cfg(not(feature = "async"))]
pub use std::sync::{Mutex, MutexGuard, OnceLock as OnceCell, RwLock};

#[cfg(feature = "multi_threaded")]
pub use std::{sync::mpsc, thread::JoinHandle};
#[cfg(not(feature = "async"))]
use thiserror::Error;
#[cfg(feature = "async")]
pub use tokio::{
    select,
    sync::{AcquireError, MutexGuard, OnceCell, Semaphore, mpsc},
    task::JoinHandle,
};
#[cfg(feature = "async")]
pub use tokio_util::sync::CancellationToken;

#[cfg(feature = "async")]
use std::sync::LockResult;

// for convenience
pub use maybe_async::maybe_async;
pub use std::sync::{Arc, Weak};

/// A wrapper for [tokio::sync::RwLock] that mocks the behavior of [std::sync::RwLock].
#[cfg(feature = "async")]
#[derive(Debug, Default)]
pub struct RwLock<T: ?Sized> {
    inner: tokio::sync::RwLock<T>,
}

#[cfg(feature = "async")]
impl<T> RwLock<T> {
    #[inline]
    pub fn new(value: T) -> Self {
        Self {
            inner: tokio::sync::RwLock::new(value),
        }
    }

    #[inline]
    pub async fn read(&self) -> LockResult<tokio::sync::RwLockReadGuard<'_, T>> {
        Ok(self.inner.read().await)
    }

    #[inline]
    pub async fn write(&self) -> LockResult<tokio::sync::RwLockWriteGuard<'_, T>> {
        Ok(self.inner.write().await)
    }
}

/// A wrapper for [tokio::sync::Mutex] that mocks the behavior of [std::sync::Mutex].
#[cfg(feature = "async")]
#[derive(Debug, Default)]
pub struct Mutex<T: ?Sized> {
    inner: tokio::sync::Mutex<T>,
}

#[cfg(feature = "async")]
impl<T> Mutex<T> {
    #[inline]
    pub fn new(value: T) -> Self {
        Self {
            inner: tokio::sync::Mutex::new(value),
        }
    }

    #[inline]
    pub async fn lock(&self) -> LockResult<tokio::sync::MutexGuard<'_, T>> {
        Ok(self.inner.lock().await)
    }
}

#[cfg(not(feature = "async"))]
pub struct Semaphore {
    inner: std::sync::Mutex<u32>,
    condvar: std::sync::Condvar,
}

#[cfg(not(feature = "async"))]
#[derive(Debug, Error)]
pub struct AcquireError;

#[cfg(not(feature = "async"))]
impl std::fmt::Display for AcquireError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Failed to acquire semaphore.")
    }
}

/// An implementation of a limited tokio::sync::Semaphore using std::sync primitives -
/// for multi-threaded environments, where tokio::sync::Semaphore is not available.
#[cfg(not(feature = "async"))]
impl Semaphore {
    pub fn new(value: u32) -> Self {
        Self {
            inner: std::sync::Mutex::new(value),
            condvar: std::sync::Condvar::new(),
        }
    }

    pub fn acquire(&self) -> Result<SemaphorePermit<'_>, AcquireError> {
        let mut guard = self.inner.lock().unwrap();
        while *guard == 0 {
            guard = self.condvar.wait(guard).unwrap();
        }
        *guard -= 1;
        Ok(SemaphorePermit {
            sem: self,
            count: 1,
        })
    }

    pub fn acquire_many(&self, count: u32) -> Result<SemaphorePermit<'_>, AcquireError> {
        let guard = self.inner.lock().unwrap();
        let mut guard = self.condvar.wait_while(guard, |c| *c < count).unwrap();
        *guard -= count;
        Ok(SemaphorePermit { sem: self, count })
    }

    pub fn add_permits(&self, count: usize) {
        let mut guard = self.inner.lock().unwrap();
        *guard += count as u32;
        self.condvar.notify_all();
    }

    pub fn available_permits(&self) -> usize {
        *self.inner.lock().unwrap() as usize
    }
}

#[cfg(not(feature = "async"))]
pub struct SemaphorePermit<'a> {
    sem: &'a Semaphore,
    count: u32,
}

#[cfg(not(feature = "async"))]
impl SemaphorePermit<'_> {
    pub fn forget(&mut self) {
        self.count = 0;
    }
}

#[cfg(not(feature = "async"))]
impl<'a> Drop for SemaphorePermit<'a> {
    fn drop(&mut self) {
        self.sem.add_permits(self.count as usize);
    }
}