bacnet-cli 0.14.0

BACnet command-line tool for device discovery, reading, and writing
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

use std::ffi::OsStr;
use std::fs::{self, File};
use std::future::Future;
use std::path::PathBuf;
use std::process::{Child, Command, Output, Stdio};
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::Duration;

pub mod lab;
#[cfg(feature = "sc-tls")]
pub mod sc;

static NEXT: AtomicU64 = AtomicU64::new(0);

pub async fn bounded<T>(future: impl Future<Output = T>) -> T {
    tokio::time::timeout(Duration::from_secs(10), future)
        .await
        .expect("loopback test exceeded deadline")
}

pub struct Files(pub PathBuf);

impl Files {
    pub fn new() -> Self {
        let path = std::env::temp_dir().join(format!(
            "cli-sc-required-ca-{}-{}",
            std::process::id(),
            NEXT.fetch_add(1, Ordering::Relaxed)
        ));
        // Owner-only where the OS has Unix modes.
        #[cfg(unix)]
        let builder = {
            use std::os::unix::fs::DirBuilderExt;
            let mut builder = fs::DirBuilder::new();
            builder.mode(0o700);
            builder
        };
        #[cfg(not(unix))]
        let builder = fs::DirBuilder::new();
        builder.create(&path).unwrap();
        Self(path)
    }

    pub fn write(&self, name: &str, bytes: impl AsRef<[u8]>) -> PathBuf {
        let path = self.0.join(name);
        fs::write(&path, bytes).unwrap();
        path
    }
}

impl Drop for Files {
    fn drop(&mut self) {
        fs::remove_dir_all(&self.0).expect("remove ephemeral credentials/output");
    }
}

pub fn command() -> Command {
    let mut cmd = Command::new(env!("CARGO_BIN_EXE_bacnet"));
    cmd.stdin(Stdio::null()).env_remove("RUST_LOG");
    cmd
}

// Files avoid pipe backpressure. The guard owns kill AND wait even on panic or
// timeout; no blocking Command::output on the runtime serving the SC endpoints.
pub struct Process {
    child: Child,
    files: Files,
}

impl Process {
    pub fn spawn(cmd: &mut Command) -> Self {
        let files = Files::new();
        cmd.stdout(File::create(files.0.join("stdout")).unwrap())
            .stderr(File::create(files.0.join("stderr")).unwrap());
        Self {
            child: cmd.spawn().unwrap(),
            files,
        }
    }

    pub async fn output(self) -> Output {
        bounded(self.output_unbounded()).await
    }

    /// [`Self::output`] without its deadline, for a caller that sets its own.
    pub async fn output_unbounded(mut self) -> Output {
        loop {
            if let Some(status) = self.child.try_wait().unwrap() {
                return Output {
                    status,
                    stdout: fs::read(self.files.0.join("stdout")).unwrap(),
                    stderr: fs::read(self.files.0.join("stderr")).unwrap(),
                };
            }
            // Process-exit polling only, never a service-readiness barrier.
            tokio::time::sleep(Duration::from_millis(5)).await;
        }
    }
}

impl Drop for Process {
    fn drop(&mut self) {
        let _ = self.child.kill();
        self.child.wait().expect("reap CLI child");
    }
}

pub async fn run(args: impl IntoIterator<Item = impl AsRef<OsStr>>) -> Output {
    Process::spawn(command().args(args)).output().await
}

pub fn failure(output: &Output, diagnostic: &str) {
    assert!(!output.status.success(), "unexpected success");
    assert!(output.stdout.is_empty(), "failure emitted stdout");
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        stderr.contains(diagnostic),
        "expected {diagnostic}: {stderr}"
    );
    assert!(!stderr.contains("PRIVATE KEY"), "credential leaked");
}