rustrtc 0.3.89

A high-performance real-time communication library — WebRTC, RTP/SRTP, T.38 Fax, and RTP Latching
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

// Test/example crate: relax pedantic style lints that are noisy in fixtures.
#![allow(clippy::field_reassign_with_default)]
#![allow(clippy::redundant_pattern_matching)]
#![allow(clippy::while_let_loop)]
#![allow(clippy::manual_checked_ops)]
#![allow(clippy::needless_range_loop)]
#![allow(clippy::explicit_counter_loop)]
#![allow(clippy::cloned_ref_to_slice_refs)]
#![allow(clippy::zombie_processes)]
use std::process::{Command, Stdio};
use std::thread;
use std::time::Duration;

#[test]
fn test_rust_server_go_client() {
    // 0. Build Rust example (use separate target dir to avoid lock contention)
    let status = Command::new("cargo")
        .args([
            "build",
            "--example",
            "interop_pion",
            "--target-dir",
            "target/e2e",
        ])
        .status()
        .expect("Failed to build Rust example");
    assert!(status.success());

    // 1. Build Go binary
    let status = Command::new("go")
        .args(["build", "-o", "interop_pion_go", "."])
        .current_dir("examples/interop_pion_go")
        .status();

    match status {
        Ok(s) if s.success() => {}
        _ => {
            println!("Skipping test: Go build failed or go not found");
            return;
        }
    }

    // 2. Start Rust Server
    let mut server = Command::new("./target/e2e/debug/examples/interop_pion")
        .args(["server", "127.0.0.1:3000"])
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("Failed to start Rust server");

    // Give server time to start
    thread::sleep(Duration::from_secs(5));

    // 3. Start Go Client
    let client = Command::new("./examples/interop_pion_go/interop_pion_go")
        .args(["-mode", "client", "-addr", "127.0.0.1:3000"])
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("Failed to start Go client");

    // 4. Wait for client to finish (it should exit 0 after 5 pings)
    let output = client
        .wait_with_output()
        .expect("Failed to wait for Go client");

    // Kill server
    let _ = server.kill();

    if !output.status.success() {
        println!(
            "Go Client stdout: {}",
            String::from_utf8_lossy(&output.stdout)
        );
        println!(
            "Go Client stderr: {}",
            String::from_utf8_lossy(&output.stderr)
        );
    }
    if output.status.success() {
        println!(
            "Go Client stdout: {}",
            String::from_utf8_lossy(&output.stdout)
        );
    }
}

#[test]
fn test_go_server_rust_client() {
    // 0. Build Rust example
    let status = Command::new("cargo")
        .args([
            "build",
            "--example",
            "interop_pion",
            "--target-dir",
            "target/e2e",
        ])
        .status()
        .expect("Failed to build Rust example");
    assert!(status.success());

    // 1. Build Go binary
    let status = Command::new("go")
        .args(["build", "-o", "interop_pion_go", "."])
        .current_dir("examples/interop_pion_go")
        .status();

    match status {
        Ok(s) if s.success() => {}
        _ => {
            println!("Skipping test: Go build failed or go not found");
            return;
        }
    }

    // 2. Start Go Server
    let mut server = Command::new("./examples/interop_pion_go/interop_pion_go")
        .args(["-mode", "server", "-addr", "127.0.0.1:3001"]) // Use different port
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("Failed to start Go server");

    // Give server time to start
    thread::sleep(Duration::from_secs(2));

    // 3. Start Rust Client
    let mut client = Command::new("./target/e2e/debug/examples/interop_pion")
        .args(["client", "127.0.0.1:3001"])
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("Failed to start Rust client");

    // 4. Wait for client to finish (it should exit 0 after 5 pings)
    let status = client.wait().expect("Failed to wait for Rust client");

    // Kill server
    let _ = server.kill();

    assert!(status.success(), "Rust client failed");
}