dexcontrol 0.7.7-rc.4

Safe Rust API for the precompiled DexControl robot runtime
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

// Copyright (C) 2026 Dexmate Inc.
//
// This software is dual-licensed:
//
// 1. GNU Affero General Public License v3.0 (AGPL-3.0)
//    See LICENSE-AGPL for details
//
// 2. Commercial License
//    For commercial licensing terms, contact: contact@dexmate.ai
//! Read-only diagnostics, runtime contexts and timing utilities.
use crate::*;
pub struct DiagnosticClient(NonNull<ffi::dex_diagnostic_t>);
impl DiagnosticClient {
    pub fn connect(options: ConnectOptions<'_>) -> Result<Self> {
        options.with_native(|n| {
            let mut out = ptr::null_mut();
            let result = call(|e| unsafe { ffi::dex_diagnostic_create(n, &mut out, e) });
            let handle = NonNull::new(out).map(Self);
            result?;
            handle.ok_or_else(|| invalid("Runtime returned no diagnostic client"))
        })
    }
    pub fn snapshot_json(&self, timeout: Duration) -> Result<String> {
        let timeout = duration_ms(timeout)?;
        text(|out, e| unsafe {
            ffi::dex_diagnostic_snapshot_json(self.0.as_ptr(), timeout, out, e)
        })
    }
    pub fn query_ntp_json(&self, samples: usize) -> Result<String> {
        text(|out, e| unsafe {
            ffi::dex_diagnostic_query_ntp_json(self.0.as_ptr(), samples, out, e)
        })
    }
    pub fn close(&self) -> Result<()> {
        call(|e| unsafe { ffi::dex_diagnostic_shutdown(self.0.as_ptr(), e) })
    }
}
impl Drop for DiagnosticClient {
    fn drop(&mut self) {
        unsafe { ffi::dex_diagnostic_release(self.0.as_ptr()) }
    }
}
/// An explicitly sized native runtime shared by connections created through it.
pub struct Context(NonNull<ffi::dex_context_t>);
impl Context {
    pub fn new(workers: usize) -> Result<Self> {
        let mut out = ptr::null_mut();
        let result = call(|e| unsafe { ffi::dex_context_create(workers, &mut out, e) });
        let handle = NonNull::new(out).map(Self);
        result?;
        handle.ok_or_else(|| invalid("Runtime returned no context"))
    }
    pub fn connect(&self, options: ConnectOptions<'_>) -> Result<Robot> {
        options.with_native(|n| {
            let mut out = ptr::null_mut();
            let result =
                call(|e| unsafe { ffi::dex_context_connect(self.0.as_ptr(), n, &mut out, e) });
            let robot = NonNull::new(out).map(Robot);
            result?;
            robot.ok_or_else(|| invalid("Runtime returned no robot"))
        })
    }
}
impl Drop for Context {
    fn drop(&mut self) {
        unsafe { ffi::dex_context_release(self.0.as_ptr()) }
    }
}
pub fn configure_runtime(workers: u32, thread_name: Option<&str>) -> Result<()> {
    let name = thread_name.map(string).transpose()?;
    let mut n = ffi::dex_runtime_options_t::default();
    unsafe { ffi::dex_runtime_options_init(&mut n) };
    n.worker_threads = workers;
    n.thread_name_utf8 = name.as_ref().map_or(ptr::null(), |s| s.as_ptr());
    call(|e| unsafe { ffi::dex_runtime_configure(&n, e) })
}
pub fn configure_watchdog(command: Option<&str>, disabled: bool) -> Result<()> {
    let command = command.map(string).transpose()?;
    call(|e| unsafe {
        ffi::dex_watchdog_configure(
            command.as_ref().map_or(ptr::null(), |s| s.as_ptr()),
            disabled,
            e,
        )
    })
}
pub fn configure_safety(exit_on_termination: bool) -> Result<()> {
    call(|e| unsafe { ffi::dex_safety_configure(exit_on_termination, e) })
}
pub use ffi::dex_rate_limiter_stats_t as RateLimiterStats;
pub struct RateLimiter(NonNull<ffi::dex_rate_limiter_t>);
impl RateLimiter {
    pub fn new(hz: f64, window: usize, adaptive: bool) -> Result<Self> {
        let mut out = ptr::null_mut();
        let result =
            call(|e| unsafe { ffi::dex_rate_limiter_create(hz, window, adaptive, &mut out, e) });
        let handle = NonNull::new(out).map(Self);
        result?;
        handle.ok_or_else(|| invalid("Runtime returned no rate limiter"))
    }
    pub fn sleep(&self) -> Result<()> {
        call(|_| unsafe { ffi::dex_rate_limiter_sleep(self.0.as_ptr()) })
    }
    pub fn reset(&self) -> Result<()> {
        call(|_| unsafe { ffi::dex_rate_limiter_reset(self.0.as_ptr()) })
    }
    pub fn done(&self) -> Result<()> {
        call(|_| unsafe { ffi::dex_rate_limiter_done(self.0.as_ptr()) })
    }
    pub fn stats(&self) -> Result<RateLimiterStats> {
        let mut out = RateLimiterStats {
            struct_size: std::mem::size_of::<RateLimiterStats>() as u32,
            ..Default::default()
        };
        call(|_| unsafe { ffi::dex_rate_limiter_stats(self.0.as_ptr(), &mut out) })?;
        Ok(out)
    }
    pub fn actual_rate(&self) -> Result<f64> {
        let mut v = 0.;
        call(|_| unsafe { ffi::dex_rate_limiter_actual_rate(self.0.as_ptr(), &mut v) })?;
        Ok(v)
    }
    pub fn average_rate(&self) -> Result<f64> {
        let mut v = 0.;
        call(|_| unsafe { ffi::dex_rate_limiter_average_rate(self.0.as_ptr(), &mut v) })?;
        Ok(v)
    }
}
impl Drop for RateLimiter {
    fn drop(&mut self) {
        unsafe { ffi::dex_rate_limiter_release(self.0.as_ptr()) }
    }
}
// SAFETY: the C ABI synchronizes these owning handles; Drop cannot race a borrow.
unsafe impl Send for DiagnosticClient {}
unsafe impl Sync for DiagnosticClient {}
unsafe impl Send for Context {}
unsafe impl Sync for Context {}
unsafe impl Send for RateLimiter {}
unsafe impl Sync for RateLimiter {}