bugstalker 0.4.3

BugStalker is a modern and lightweight debugger for rust applications.
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

use crate::common::TestHooks;
use crate::common::TestInfo;
use crate::{SIGNALS_APP, SLEEPER_APP, assert_no_proc, prepare_debugee_process};
use bugstalker::debugger::DebuggerBuilder;
use nix::sys::signal;
use nix::sys::signal::{SIGINT, SIGUSR1, SIGUSR2};
use serial_test::serial;
use std::thread;
use std::time::Duration;

#[test]
#[serial]
fn test_signal_stop_single_thread() {
    let process = prepare_debugee_process(SIGNALS_APP, &["single_thread"]);
    let debugee_pid = process.pid();
    let info = TestInfo::default();
    let builder = DebuggerBuilder::new().with_hooks(TestHooks::new(info.clone()));
    let mut debugger = builder.build(process).unwrap();

    debugger.set_breakpoint_at_line("signals.rs", 12).unwrap();

    thread::spawn(move || {
        thread::sleep(Duration::from_secs(4));
        signal::kill(debugee_pid, SIGUSR1).unwrap();
    });

    debugger.start_debugee().unwrap();

    std::thread::sleep(Duration::from_secs(1));

    debugger.continue_debugee().unwrap();
    assert_eq!(info.line.take(), Some(12));

    debugger.continue_debugee().unwrap();

    assert_no_proc!(debugee_pid);
}

#[test]
#[serial]
fn test_signal_stop_multi_thread() {
    let process = prepare_debugee_process(SIGNALS_APP, &["multi_thread"]);
    let debugee_pid = process.pid();
    let info = TestInfo::default();
    let builder = DebuggerBuilder::new().with_hooks(TestHooks::new(info.clone()));
    let mut debugger = builder.build(process).unwrap();

    debugger.set_breakpoint_at_line("signals.rs", 42).unwrap();

    thread::spawn(move || {
        thread::sleep(Duration::from_secs(4));
        signal::kill(debugee_pid, SIGUSR1).unwrap();
    });

    debugger.start_debugee().unwrap();
    std::thread::sleep(Duration::from_secs(1));

    debugger.continue_debugee().unwrap();
    assert_eq!(info.line.take(), Some(42));

    debugger.continue_debugee().unwrap();
    assert_no_proc!(debugee_pid);
}

#[test]
#[serial]
fn test_signal_stop_multi_thread_multiple_signal() {
    let process = prepare_debugee_process(SIGNALS_APP, &["multi_thread_multi_signal"]);
    let debugee_pid = process.pid();
    let info = TestInfo::default();
    let builder = DebuggerBuilder::new().with_hooks(TestHooks::new(info.clone()));
    let mut debugger = builder.build(process).unwrap();

    debugger.set_breakpoint_at_line("signals.rs", 62).unwrap();

    thread::spawn(move || {
        thread::sleep(Duration::from_secs(4));
        signal::kill(debugee_pid, SIGUSR1).unwrap();
        signal::kill(debugee_pid, SIGUSR2).unwrap();
    });

    debugger.start_debugee().unwrap();

    std::thread::sleep(Duration::from_secs(1));

    debugger.continue_debugee().unwrap();
    debugger.continue_debugee().unwrap();

    assert_eq!(info.line.take(), Some(62));
    debugger.continue_debugee().unwrap();

    assert_no_proc!(debugee_pid);
}

#[test]
#[serial]
fn test_transparent_signals() {
    let process = prepare_debugee_process(SLEEPER_APP, &["-s", "1"]);
    let debugee_pid = process.pid();
    let info = TestInfo::default();
    let builder = DebuggerBuilder::new().with_hooks(TestHooks::new(info.clone()));
    let mut debugger = builder.build(process).unwrap();

    thread::spawn(move || {
        thread::sleep(Duration::from_secs(2));
        signal::kill(debugee_pid, SIGINT).unwrap();
    });

    debugger.start_debugee().unwrap();

    // debugger takeover control here, just check that debugee still alive
    assert!(!debugger.thread_state().unwrap().is_empty());

    drop(debugger);
    assert_no_proc!(debugee_pid);
}