dstest 0.1.2

Deterministic Simulation Testing for containerised services
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

use std::net::TcpStream;
use std::sync::Arc;
use std::time::Duration;

use mlua::{Lua, Result, Table};

use crate::bindings::context::BindingContext;

pub fn register(lua: &Lua, dstest: &Table, ctx: &BindingContext) -> Result<()> {
    let state = Arc::clone(&ctx.state);
    let config = Arc::clone(&ctx.config);

    let tcp_fn = lua.create_function(move |lua, (id, port): (String, u16)| {
        let host = {
            let state = state.lock().expect("poisoned lock");
            state
                .subject_hosts
                .get(&id)
                .cloned()
                .ok_or_else(|| mlua::Error::RuntimeError(format!("unknown subject {}", id)))?
        };

        let host_ip = host.split(':').next().unwrap_or(&host);
        let addr = format!("{}:{}", host_ip, port);

        let timeout_secs = {
            let cfg = config.lock().expect("poisoned lock");
            cfg.http_timeout_secs
        };

        match TcpStream::connect_timeout(
            &addr
                .parse()
                .map_err(|e| mlua::Error::RuntimeError(format!("invalid address: {}", e)))?,
            Duration::from_secs(timeout_secs),
        ) {
            Ok(_stream) => {
                let t = lua.create_table()?;
                t.set("connected", true)?;
                t.set("addr", addr)?;
                Ok(t)
            }
            Err(e) => {
                let t = lua.create_table()?;
                t.set("connected", false)?;
                t.set("error", e.to_string())?;
                t.set("addr", addr)?;
                Ok(t)
            }
        }
    })?;

    dstest.set("tcp", tcp_fn)?;
    Ok(())
}