spvirit-tools 0.1.20

PVAccess client/server tools for EPICS
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

//! Dynamic add / edit / remove of PVs against a running server, over the wire.

use std::net::{IpAddr, Ipv4Addr, TcpListener, UdpSocket};
use std::time::Duration;

use spvirit_client::pvget;
use spvirit_codec::spvd_decode::format_compact_value;
use spvirit_tools::spvirit_client::types::PvGetOptions;
use spvirit_tools::spvirit_server::pv::AnyPv;
use spvirit_tools::spvirit_server::pva_server::PvaServer;
use spvirit_types::ScalarValue;

fn free_tcp_port() -> Option<u16> {
    TcpListener::bind("127.0.0.1:0").ok()?.local_addr().ok().map(|a| a.port())
}
fn free_udp_port() -> Option<u16> {
    UdpSocket::bind("127.0.0.1:0").ok()?.local_addr().ok().map(|a| a.port())
}
fn opts(pv: &str, tcp: u16, udp: u16, timeout: Duration) -> PvGetOptions {
    let mut o = PvGetOptions::new(pv.to_string());
    o.tcp_port = tcp;
    o.udp_port = udp;
    o.timeout = timeout;
    o.search_addr = Some(IpAddr::V4(Ipv4Addr::LOCALHOST));
    o.bind_addr = Some(IpAddr::V4(Ipv4Addr::LOCALHOST));
    o
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn dynamic_add_edit_remove_over_wire() {
    let (Some(tcp), Some(udp)) = (free_tcp_port(), free_udp_port()) else {
        eprintln!("Skipping: cannot bind ports");
        return;
    };

    let server = PvaServer::serve(Vec::<AnyPv>::new())
        .port(tcp)
        .udp_port(udp)
        .listen_ip(IpAddr::V4(Ipv4Addr::LOCALHOST))
        .start()
        .await;
    tokio::time::sleep(Duration::from_millis(300)).await;

    // ADD: writable i32 PV appears and is gettable.
    let _h = server.add_scalar("DYN:VAL", ScalarValue::I32(42), true).await;
    tokio::time::sleep(Duration::from_millis(100)).await;
    let r = pvget(&opts("DYN:VAL", tcp, udp, Duration::from_secs(5)))
        .await
        .expect("pvget after add");
    assert!(
        format_compact_value(&r.value).contains("42"),
        "expected 42, got {}",
        format_compact_value(&r.value)
    );

    // EDIT: value updates over the wire.
    server.store().set_value("DYN:VAL", ScalarValue::I32(99)).await;
    let r = pvget(&opts("DYN:VAL", tcp, udp, Duration::from_secs(5)))
        .await
        .expect("pvget after edit");
    assert!(
        format_compact_value(&r.value).contains("99"),
        "expected 99, got {}",
        format_compact_value(&r.value)
    );

    // REMOVE: PV no longer resolves (short timeout — negative lookup).
    assert!(server.store().remove("DYN:VAL").await);
    let res = pvget(&opts("DYN:VAL", tcp, udp, Duration::from_millis(800))).await;
    assert!(res.is_err(), "removed PV should not resolve, got {res:?}");

    server.abort();
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn dynamic_enum_add_and_set_over_wire() {
    let (Some(tcp), Some(udp)) = (free_tcp_port(), free_udp_port()) else {
        eprintln!("Skipping: cannot bind ports");
        return;
    };
    let server = PvaServer::serve(Vec::<AnyPv>::new())
        .port(tcp)
        .udp_port(udp)
        .listen_ip(IpAddr::V4(Ipv4Addr::LOCALHOST))
        .start()
        .await;
    tokio::time::sleep(Duration::from_millis(300)).await;

    server
        .add_enum("DYN:ENUM", vec!["OFF".into(), "ON".into(), "TRIP".into()], 0, true)
        .await;
    tokio::time::sleep(Duration::from_millis(100)).await;
    let r = pvget(&opts("DYN:ENUM", tcp, udp, Duration::from_secs(5)))
        .await
        .expect("pvget enum");
    // NOTE: format_compact_value renders NTEnum as `value={index=N,
    // choices=[...]}` — the choices array always lists every choice
    // string regardless of the selected index, so asserting `contains`
    // on a choice string (e.g. "TRIP") would pass unconditionally and
    // never actually test which index is selected. Assert on the
    // rendered `index=N` field instead, which does vary with the value.
    assert!(
        format_compact_value(&r.value).contains("index=0"),
        "expected index=0, got {}",
        format_compact_value(&r.value)
    );

    // set index 2 via put_nt
    server
        .store()
        .put_nt(
            "DYN:ENUM",
            spvirit_types::NtPayload::Enum(spvirit_types::NtEnum::new(
                2,
                vec!["OFF".into(), "ON".into(), "TRIP".into()],
            )),
        )
        .await;
    let r = pvget(&opts("DYN:ENUM", tcp, udp, Duration::from_secs(5)))
        .await
        .expect("pvget enum 2");
    assert!(
        format_compact_value(&r.value).contains("index=2"),
        "expected index=2, got {}",
        format_compact_value(&r.value)
    );

    server.abort();
}