bacnet-server 0.12.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
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

//! The reservation follows the final network owner even when stop cannot unwrap it.
use super::*;
use bacnet_objects::network_port::{BipPortConfig, NetworkPortObject};

#[path = "sc_network_number_tests.rs"]
mod sc_network_number_tests;

#[tokio::test]
async fn registered_port_bare_drop_and_retained_network_refusal_keep_lease() {
    for stop_first in [false, true] {
        let oid = ObjectIdentifier::new(ObjectType::NETWORK_PORT, 1).unwrap();
        let mut db = ObjectDatabase::new();
        db.add(Box::new(
            NetworkPortObject::new_bip(
                1,
                "selected",
                BipPortConfig {
                    ip_address: [127, 0, 0, 1],
                    udp_port: 0,
                    ..Default::default()
                },
            )
            .unwrap(),
        ))
        .unwrap();
        let config = ServerConfig {
            registered_network_port: Some(oid),
            ..Default::default()
        };
        let transport = BipTransport::new(Ipv4Addr::LOCALHOST, 0, Ipv4Addr::BROADCAST);
        let mut server = BACnetServer::start(config, db, transport).await.unwrap();
        let db = server.database().clone();
        let network = server.test_network().clone();
        let address = network.transport().normal_bip_endpoint().unwrap();
        if stop_first {
            assert!(server.stop().await.is_err());
        }
        drop(server);
        assert!(db.write().await.remove(&oid).is_err());
        assert!(std::net::UdpSocket::bind(address).is_err());
        drop(network);
        tokio::time::timeout(Duration::from_secs(3), async {
            loop {
                match db.write().await.remove(&oid) {
                    Ok(Some(_)) => break,
                    Err(_) => tokio::task::yield_now().await,
                    other => panic!("unexpected removal result: {}", other.is_ok()),
                }
            }
        })
        .await
        .unwrap();
        // Lease cannot disappear before the socket's final destruction.
        let _reused = std::net::UdpSocket::bind(address).unwrap();
    }
}

#[tokio::test]
async fn network_number_server_held_learning_preserves_audit_ack_progress() {
    use bacnet_endpoint_core::coordinator::CanonicalPeer;
    let oid = ObjectIdentifier::new(ObjectType::NETWORK_PORT, 1).unwrap();
    let mut db = ObjectDatabase::new();
    db.add(Box::new(
        NetworkPortObject::new_bip(
            1,
            "selected",
            BipPortConfig {
                ip_address: [127, 0, 0, 1],
                udp_port: 0,
                ..Default::default()
            },
        )
        .unwrap(),
    ))
    .unwrap();
    let mut server = BACnetServer::start(
        ServerConfig {
            registered_network_port: Some(oid),
            ..Default::default()
        },
        db,
        BipTransport::new(Ipv4Addr::LOCALHOST, 0, Ipv4Addr::new(127, 255, 255, 255)),
    )
    .await
    .unwrap();
    let address = server
        .test_network()
        .transport()
        .normal_bip_endpoint()
        .unwrap();
    let peer = tokio::net::UdpSocket::bind((Ipv4Addr::LOCALHOST, 0))
        .await
        .unwrap();
    let mac =
        bacnet_transport::bvll::encode_bip_mac([127, 0, 0, 1], peer.local_addr().unwrap().port());
    let (operation, acknowledged) = server
        .notification_transactions
        .reserve(
            CanonicalPeer::direct(&mac),
            ConfirmedServiceChoice::CONFIRMED_AUDIT_NOTIFICATION,
        )
        .unwrap();
    let db = server.database().clone();
    let guard = db.read().await;
    peer.send_to(
        &[
            0x81, 4, 0, 16, 10, 1, 1, 8, 0xba, 0xc0, 1, 0x80, 0x13, 0, 19, 1,
        ],
        address,
    )
    .await
    .unwrap();
    tokio::time::timeout(Duration::from_secs(1), async {
        while db.try_read().is_ok() {
            tokio::task::yield_now().await;
        }
    })
    .await
    .unwrap();
    peer.send_to(
        &[
            0x81,
            10,
            0,
            9,
            1,
            0,
            0x20,
            operation.invoke_id(),
            ConfirmedServiceChoice::CONFIRMED_AUDIT_NOTIFICATION.to_raw(),
        ],
        address,
    )
    .await
    .unwrap();
    assert!(matches!(
        tokio::time::timeout(Duration::from_secs(1), acknowledged)
            .await
            .unwrap()
            .unwrap(),
        CovAckResult::Ack
    ));
    drop(operation);
    // Stop must abort the blocked writer without waiting for this DB reader.
    tokio::time::timeout(Duration::from_secs(1), server.stop())
        .await
        .unwrap()
        .unwrap();
    drop(guard);
    assert!(db.write().await.remove(&oid).unwrap().is_some());
}