smb 0.6.0

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

#![cfg(not(feature = "single_threaded"))]
use serial_test::serial;
use smb::{
    connection::EncryptionMode,
    packets::{
        fscc::*,
        smb2::{CreateDisposition, NotifyFilter},
    },
    resource::Resource,
    sync_helpers::*,
    ConnectionConfig,
};
use std::sync::Arc;
mod common;

use common::make_server_connection;
const NEW_FILE_NAME_UNDER_WORKDIR: &str = "test_file.txt";

#[test_log::test(maybe_async::test(
    not(feature = "async"),
    async(feature = "async", tokio::test(flavor = "multi_thread"))
))]
#[serial]
async fn test_smb_notify() -> Result<(), Box<dyn std::error::Error>> {
    let (_connection, _session, tree) = make_server_connection(
        "MyShare",
        ConnectionConfig {
            encryption_mode: EncryptionMode::Disabled,
            ..Default::default()
        }
        .into(),
    )
    .await?;

    // Create the file
    {
        tree.create_file(
            NEW_FILE_NAME_UNDER_WORKDIR,
            CreateDisposition::Create,
            FileAccessMask::new()
                .with_generic_read(true)
                .with_generic_write(true),
        )
        .await?;
    }

    let dir = tree
        .open_existing("", FileAccessMask::new().with_generic_read(true))
        .await?;

    let notified_sem = Arc::new(Semaphore::new(0));
    start_notify_task(notified_sem.clone(), dir);
    // Launch tasks to wait for notifications.
    // Another connection now modifying the file...
    delete_file_from_another_connection("MyShare").await?;
    // Wait for notifiactions to arrive.
    let _p = notified_sem.acquire().await?;
    Ok(())
}

#[maybe_async::async_impl]
fn start_notify_task(sem: Arc<Semaphore>, r: Resource) {
    let filter = NotifyFilter::new()
        .with_file_name(true)
        .with_dir_name(true)
        .with_attributes(true)
        .with_last_write(true)
        .with_last_access(true);
    tokio::spawn(async move {
        for notification in r.unwrap_dir().watch(filter, true).await.unwrap() {
            if notification.action == NotifyAction::Removed {
                sem.add_permits(1);
                break;
            }
        }
    });
}
#[maybe_async::sync_impl]
fn start_notify_task(sem: Arc<Semaphore>, r: Resource) {
    let filter = NotifyFilter::new()
        .with_file_name(true)
        .with_dir_name(true)
        .with_attributes(true)
        .with_last_write(true)
        .with_last_access(true);
    std::thread::spawn(move || {
        for notification in r.unwrap_dir().watch(filter, true).unwrap() {
            if notification.action == NotifyAction::Removed {
                sem.add_permits(1);
                break;
            }
        }
    });
}
#[maybe_async::maybe_async]
async fn delete_file_from_another_connection(
    share_name: &str,
) -> Result<(), Box<dyn std::error::Error>> {
    let (_connection, _session, tree) = make_server_connection(
        share_name,
        ConnectionConfig {
            encryption_mode: EncryptionMode::Disabled,
            ..Default::default()
        }
        .into(),
    )
    .await?;

    let file = tree
        .open_existing(
            NEW_FILE_NAME_UNDER_WORKDIR,
            FileAccessMask::new()
                .with_generic_all(true)
                .with_delete(true),
        )
        .await?
        .unwrap_file();

    file.set_file_info(FileDispositionInformation {
        delete_pending: true.into(),
    })
    .await?;

    // We are exiting, and file is closed, and deleted!
    Ok(())
}