bugstalker 0.4.5

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
117
118
119
120
121
122
123
124
125

import unittest
from helper import Debugger
import socket
import threading
import time
import signal


def send_tcp_request():
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect(("localhost", 8080))
    client.send("hello, bs!".encode())
    client.close()


SUPPORTED_TOKIO_V = [
  "1_40",
  "1_41",  
  "1_42",  
  "1_43",  
  "1_44",  
];


def tokio_binaries():
    binaries = []
    for v in SUPPORTED_TOKIO_V:
        binaries.append(f"tokio_{v}")
    return binaries

class CommandTestCase(unittest.TestCase):           
    def test_runtime_info_1(self):
        for binary in tokio_binaries():
            self.debugger = Debugger(path=f"./examples/tokio_tcp/{binary}/target/debug/{binary}")
            self.debugger.cmd_re('run', r'Listening on: .*:8080')

            thread = threading.Thread(target=send_tcp_request)
            thread.start()
            time.sleep(7)

            self.debugger.debugee_process().send_signal(signal.SIGINT)
            self.debugger.cmd_re(
                'async backtrace',
                r'Thread .* block on:',
                f'async fn {binary}::main',
                'Async worker',
                'Async worker',
                'Async worker'
            )
            self.debugger.cmd_re(
                'async backtrace all',
                r'Thread .* block on:',
                f'async fn {binary}::main',
                'Async worker',
                'Async worker',
                'Async worker',
                f'#0 async fn {binary}::main::{{async_block#0}}',
                'suspended at await point 2',
                '#1 future tokio::sync::oneshot::Receiver<i32>',
                f'#0 async fn {binary}::main::{{async_block#0}}::{{async_block#1}}',
                'suspended at await point 0',
                '#1 sleep future, sleeping',
            )
            # switch to worker thread (hope that thread 2 is a worker)
            self.debugger.cmd('thread switch 2')
            self.debugger.cmd('async task', 'no active task found for current worker')

            # there should be two task with "main" in their names
            self.debugger.cmd('async task .*main.*', 'Task id', 'Task id')

    def test_runtime_info_2(self):
        """Stop async runtime at breakpoint and assert futures state"""
        
        for binary in tokio_binaries():
            self.debugger = Debugger(path=f"./examples/tokio_tcp/{binary}/target/debug/{binary}")
            self.debugger.cmd('break main.rs:54')
            self.debugger.cmd_re('run', r'Listening on: .*:8080')

            thread = threading.Thread(target=send_tcp_request)
            thread.start()
            time.sleep(6)

            self.debugger.cmd_re(
                'async backtrace',
                'Thread .* block on',
                f'#0 async fn {binary}::main',
                'Async worker',
                'Active task',
                f'#0 async fn {binary}::main::{{async_block#0}}'
            )
            self.debugger.cmd(
                'async task',
                f'#0 async fn {binary}::main::{{async_block#0}}',
                'suspended at await point 1',
                '#1 sleep future, sleeping'
            )
            
    def test_step_over(self):
        """Do async step over until future ends"""
        
        for binary in tokio_binaries():
            self.debugger = Debugger(path=f"./examples/tokio_vars/{binary}/target/debug/{binary}")
            self.debugger.cmd('break main.rs:29')
            self.debugger.cmd('run')
            self.debugger.cmd_re('async next', r'Task id: \d', r'30     let _b = inner_1')
            self.debugger.cmd_re('async next', r'Task id: \d', r'32     tokio::time::sleep')
            self.debugger.cmd_re('async next', r'Task id: \d', r'28     let _a')
            self.debugger.cmd_re('async next', r'Task id: \d', r'26 async fn f2')
            self.debugger.cmd_re('async next', r'Task id: \d', r'32     tokio::time::sleep')
            self.debugger.cmd_re('async next', r'Task id: \d', r'33     let _c = inner_1')
            self.debugger.cmd_re('async next', r'Task id: \d', r'34 }')
            self.debugger.cmd_re('async next', r'Task #\d completed, stopped')

    def test_step_out(self):
        """Do async step out"""
        
        for binary in tokio_binaries():
            self.debugger = Debugger(path=f"./examples/tokio_vars/{binary}/target/debug/{binary}")
            self.debugger.cmd('break main.rs:18')
            self.debugger.cmd('break main.rs:28')
            self.debugger.cmd('run', 'Hit breakpoint 1')
            self.debugger.cmd_re('async stepout', r'Task #\d completed, stopped')
            self.debugger.cmd('continue', 'Hit breakpoint 2')
            self.debugger.cmd_re('async stepout', r'Task #\d completed, stopped')