fix: pass dap-server to ct/start-replay

alehander92 · alehander92 · commit efd42b665c46 · 2025-10-13T21:08:04.000+03:00
diff --git a/src/db-backend/tests/dap_backend_tcp.rs b/src/db-backend/tests/dap_backend_tcp.rs
@@ -0,0 +1,180 @@
+use db_backend::dap::{self, DapClient, DapMessage, LaunchRequestArguments};
+use db_backend::dap_server;
+use db_backend::dap_types::StackTraceArguments;
+use serde_json::json;
+use std::io::BufReader;
+use std::os::unix::net::UnixStream;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::thread;
+use std::time::Duration;
+
+fn wait_for_socket(path: &Path) {
+    for _ in 0..50 {
+        if path.exists() {
+            return;
+        }
+        thread::sleep(Duration::from_millis(100));
+    }
+    // println!("{path:?}");
+    panic!("socket not created");
+}
+
+#[test]
+fn test_backend_dap_server() {
+    let bin = env!("CARGO_BIN_EXE_db-backend");
+    let pid = std::process::id() as usize;
+    let trace_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("trace");
+
+    let socket_path = dap_server::socket_path_for(std::process::id() as usize);
+    let mut child = Command::new(bin).arg("dap-server").arg(&socket_path).spawn().unwrap();
+    wait_for_socket(&socket_path);
+
+    let stream = UnixStream::connect(&socket_path).unwrap();
+    let mut reader = BufReader::new(stream.try_clone().unwrap());
+    let mut writer = stream;
+
+    let mut client = DapClient::default();
+    let init = client.request("initialize", json!({}));
+    dap::write_message(&mut writer, &init).unwrap();
+    let launch_args = LaunchRequestArguments {
+        program: Some("main".to_string()),
+        trace_folder: Some(trace_dir),
+        trace_file: None,
+        pid: Some(pid as u64),
+        cwd: None,
+        no_debug: None,
+        restart: None,
+        name: None,
+        request: None,
+        typ: None,
+        session_id: None,
+    };
+    let launch = client.launch(launch_args).unwrap();
+    dap::write_message(&mut writer, &launch).unwrap();
+
+    let msg1 = dap::from_reader(&mut reader).unwrap();
+    match msg1 {
+        DapMessage::Response(r) => {
+            assert_eq!(r.command, "initialize");
+            println!("{:?}", r.body);
+            // assert!(r.body["supportsLoadedSourcesRequest"].as_bool().unwrap());
+            assert!(r.body["supportsStepBack"].as_bool().unwrap());
+            assert!(r.body["supportsConfigurationDoneRequest"].as_bool().unwrap());
+            assert!(r.body["supportsDisassembleRequest"].as_bool().unwrap());
+            assert!(r.body["supportsLogPoints"].as_bool().unwrap());
+            assert!(r.body["supportsRestartRequest"].as_bool().unwrap());
+        }
+        _ => panic!(),
+    }
+    let msg2 = dap::from_reader(&mut reader).unwrap();
+    match msg2 {
+        DapMessage::Event(e) => assert_eq!(e.event, "initialized"),
+        _ => panic!(),
+    }
+    let conf_done = client.request("configurationDone", json!({}));
+    dap::write_message(&mut writer, &conf_done).unwrap();
+    let msg3 = dap::from_reader(&mut reader).unwrap();
+    match msg3 {
+        DapMessage::Response(r) => assert_eq!(r.command, "launch"),
+        _ => panic!(),
+    }
+    let msg4 = dap::from_reader(&mut reader).unwrap();
+    match msg4 {
+        DapMessage::Response(r) => assert_eq!(r.command, "configurationDone"),
+        _ => panic!(),
+    }
+
+    let msg5 = dap::from_reader(&mut reader).unwrap();
+    match msg5 {
+        DapMessage::Event(e) => {
+            assert_eq!(e.event, "stopped");
+            assert_eq!(e.body["reason"], "entry");
+        }
+        _ => panic!("expected a stopped event, but got {:?}", msg5),
+    }
+
+    let msg_complete_move = dap::from_reader(&mut reader).unwrap();
+    match msg_complete_move {
+        DapMessage::Event(e) => {
+            assert_eq!(e.event, "ct/complete-move");
+        }
+        _ => panic!("expected a complete move events, but got {:?}", msg_complete_move),
+    }
+
+    let threads_request = client.request("threads", json!({}));
+    dap::write_message(&mut writer, &threads_request).unwrap();
+    let msg_threads = dap::from_reader(&mut reader).unwrap();
+    match msg_threads {
+        DapMessage::Response(r) => {
+            assert_eq!(r.command, "threads");
+            assert_eq!(r.body["threads"][0]["id"], 1);
+        }
+        _ => panic!(
+            "expected a Response DapMessage after a threads request, but got {:?}",
+            msg_threads
+        ),
+    }
+
+    let stack_trace_request = client.request(
+        "stackTrace",
+        serde_json::to_value(StackTraceArguments {
+            thread_id: 1,
+            format: None,
+            levels: None,
+            start_frame: None,
+        })
+        .unwrap(),
+    );
+    dap::write_message(&mut writer, &stack_trace_request).unwrap();
+    let msg_stack_trace = dap::from_reader(&mut reader).unwrap();
+    match msg_stack_trace {
+        DapMessage::Response(r) => assert_eq!(r.command, "stackTrace"), // TODO: test stackFrames / totalFrames ?
+        _ => panic!(),
+    }
+
+    drop(writer);
+    drop(reader);
+    let _ = child.wait().unwrap();
+}
+
+#[test]
+fn test_dap_initialization_sequence() {
+    let bin = env!("CARGO_BIN_EXE_db-backend");
+    let pid = std::process::id() as usize;
+
+    let socket_path = dap_server::socket_path_for(pid);
+    let mut child = Command::new(bin).arg("dap-server").arg(&socket_path).spawn().unwrap();
+    wait_for_socket(&socket_path);
+
+    let stream = UnixStream::connect(&socket_path).unwrap();
+    let mut reader = BufReader::new(stream.try_clone().unwrap());
+    let mut writer = stream;
+
+    let mut client = DapClient::default();
+    let init = client.request("initialize", json!({}));
+    dap::write_message(&mut writer, &init).unwrap();
+
+    let msg1 = dap::from_reader(&mut reader).unwrap();
+    match msg1 {
+        DapMessage::Response(r) => {
+            assert_eq!(r.command, "initialize");
+            assert!(r.body["supportsStepBack"].as_bool().unwrap());
+            assert!(r.body["supportsConfigurationDoneRequest"].as_bool().unwrap());
+            assert!(r.body["supportsDisassembleRequest"].as_bool().unwrap());
+            assert!(r.body["supportsLogPoints"].as_bool().unwrap());
+            assert!(r.body["supportsRestartRequest"].as_bool().unwrap());
+        }
+        _ => panic!("expected an initialize response, but got {:?}", msg1),
+    }
+
+    let msg2 = dap::from_reader(&mut reader).unwrap();
+    match msg2 {
+        DapMessage::Event(e) => assert_eq!(e.event, "initialized"),
+        _ => panic!("expected an initialized event, but got {:?}", msg2),
+    }
+
+    drop(writer);
+    drop(reader);
+    let _ = child.wait().unwrap();
+}
diff --git a/src/db-backend/transport_spec.md b/src/db-backend/transport_spec.md
@@ -0,0 +1,58 @@
+# DB-Backend Transport Specification
+
+## 1. Introduction
+
+This document specifies the transport mechanism used by the `db-backend` component for communication with external clients, primarily debuggers or development environments. The transport layer facilitates the exchange of messages conforming to the Debug Adapter Protocol (DAP).
+
+## 2. Protocol Overview
+
+The `db-backend` utilizes the Debug Adapter Protocol (DAP) as its primary communication protocol. DAP defines a generic protocol for debuggers and development environments to communicate with debug adapters. This specification focuses on how these DAP messages are transmitted over a communication channel.
+
+## 3. Message Structure
+
+DAP messages are exchanged using a simple, length-prefixed JSON format. Each message consists of two parts:
+
+1.  **Header**: A set of HTTP-like headers, terminated by a `\r\n\r\n` sequence. The most crucial header is `Content-Length`, which indicates the size of the following JSON payload in bytes.
+    ```/dev/null/example.txt#L1-2
+    Content-Length: 123
+    Content-Type: application/json
+    ```
+    The `Content-Type` header is optional but recommended. If present, its value must be `application/json`.
+
+2.  **Content**: The actual DAP message, which is a JSON object encoded in UTF-8. The size of this content must exactly match the `Content-Length` specified in the header.
+
+Example of a complete message:
+```/dev/null/example.txt#L1-5
+Content-Length: 72
+Content-Type: application/json
+
+{"seq":1, "type":"request", "command":"initialize", "arguments":{"adapterID":"db"}}
+```
+
+## 4. Transport Layer
+
+The `db-backend` primarily uses **Standard I/O (stdin/stdout)** for its transport layer.
+
+*   **Input (stdin)**: The `db-backend` reads incoming DAP messages from its standard input stream.
+*   **Output (stdout)**: The `db-backend` writes outgoing DAP messages to its standard output stream.
+
+Each message (header + content) is transmitted as a contiguous block of bytes. There should be no additional delimiters or framing between messages beyond the `\r\n\r\n` separator between the header and the content.
+
+## 5. Error Handling
+
+### 5.1. Malformed Messages
+
+If the `db-backend` receives a message that does not conform to the specified header and content format (e.g., missing `Content-Length`, invalid `Content-Length`, or non-JSON content), it should:
+
+*   Attempt to log the error internally (if a logging mechanism is available).
+*   Discard the malformed message.
+*   Continue processing subsequent messages, if possible.
+*   It should **not** send an error response over the DAP channel for transport-layer parsing errors, as the message might be too corrupted to respond to meaningfully.
+
+### 5.2. Protocol Errors (DAP Level)
+
+Errors within the DAP message content (e.g., unknown command, invalid arguments for a command) should be handled according to the DAP specification, typically by sending a `response` message with the `success` field set to `false` and an appropriate `message` and `body.error` field.
+
+### 5.3. Transport Failures
+
+If the standard I/O streams are closed unexpectedly or encounter read/write errors, the `db-backend` should terminate gracefully, logging the nature of the transport failure.
