bacnet-server 0.15.0

BACnet server: APDU dispatch and service handlers
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

use super::*;

#[tokio::test]
async fn target_reporter_off_runtime_silent_change_commits_without_worker() {
    let mut target = reporter();
    target.set_audit_level(AuditLevel::NONE).unwrap();
    target
        .set_auditable_operations(AuditOperationFlags::empty())
        .unwrap();
    let mut fixture = server(target).await;
    let database = Arc::clone(fixture.server.database());
    let reporter_id = oid(ObjectType::AUDIT_REPORTER, 1);
    let outcome = std::thread::spawn(move || {
        assert!(tokio::runtime::Handle::try_current().is_err());
        let mut database = database.blocking_write();
        let reporter = database.get_mut(&reporter_id).unwrap();
        let mut operations = AuditOperationFlags::empty();
        operations.insert(AuditOperation::WRITE);
        reporter.configure_audit_reporter_internal(
            AuditLevel::NONE,
            operations,
            false,
            None,
            BACnetPriorityFilter::all(),
            None,
        )?;
        reporter.write_property(
            PropertyIdentifier::DESCRIPTION,
            None,
            PropertyValue::CharacterString("synchronous silent change".into()),
            None,
        )?;
        assert_eq!(
            reporter.read_property(PropertyIdentifier::AUDITABLE_OPERATIONS, None)?,
            PropertyValue::BitString {
                unused_bits: operations.to_bacnet().0,
                data: operations.to_bacnet().1
            },
        );
        assert_eq!(
            reporter.read_property(PropertyIdentifier::DESCRIPTION, None)?,
            PropertyValue::CharacterString("synchronous silent change".into()),
        );
        // A notification-producing change still rejects before committing when
        // no runtime is available; the silent path must not weaken this guard.
        assert!(
            reporter
                .configure_audit_reporter_internal(
                    AuditLevel::AUDIT_ALL,
                    operations,
                    false,
                    None,
                    BACnetPriorityFilter::all(),
                    None,
                )
                .is_err()
        );
        assert_eq!(
            reporter.read_property(PropertyIdentifier::AUDIT_LEVEL, None)?,
            PropertyValue::Enumerated(AuditLevel::NONE.to_raw())
        );
        Ok::<_, Error>(())
    })
    .join()
    .unwrap();
    assert!(outcome.is_ok(), "silent active change failed: {outcome:?}");
    settle().await;
    assert!(fixture.transport.sent.lock().unwrap().is_empty());
    assert!(
        fixture
            .server
            .notification_transactions
            .delivery_workers_idle()
    );
    assert_eq!(
        fixture.server.notification_transactions.audit_resources(),
        (false, 0, 64)
    );
    let owner = fixture
        .server
        .notification_transactions
        .audit_owner_lease()
        .unwrap();
    fixture
        .server
        .notification_transactions
        .seal_audit_owner(&owner);
    for closed in [false, true] {
        if closed {
            fixture.server.notification_transactions.close();
        }
        let database = Arc::clone(fixture.server.database());
        std::thread::spawn(move || {
            let mut database = database.blocking_write();
            let reporter = database.get_mut(&reporter_id).unwrap();
            assert!(
                reporter
                    .write_property(
                        PropertyIdentifier::DESCRIPTION,
                        None,
                        PropertyValue::CharacterString("must not commit".into()),
                        None,
                    )
                    .is_err()
            );
            assert_eq!(
                reporter
                    .read_property(PropertyIdentifier::DESCRIPTION, None)
                    .unwrap(),
                PropertyValue::CharacterString("synchronous silent change".into())
            );
        })
        .join()
        .unwrap();
    }
    drop(owner);
    fixture.server.stop().await.unwrap();
}