fix: small fixes for raw diff index & db-backend test

small fixes after rebase; however also a `main.rs` fix, because
we were handling structured diff CLI arg, as path, but it was the source
not sure how this ever worked
also a small fix for the dap server test (putting the new way to called the binary
in the right place, sorry)

copying commit message from original raw_diff_index commit by me and Nedy for context:

(a624ea0):

  fix: try to pass raw diff index content to db-backend instead of hardcoding path

    Part of a pairing session with Nedy;
    TODO: (alexander: i decided for now to go with passing it directly with CLI for
    faster prototype/working version)
    still hacky as CLI args have limited size/memory, but for initial internal version
    hopefully ok

Author: alehander92

src/db-backend/src/dap_server.rs

@@ -86,7 +86,7 @@ pub fn run(socket_path: &PathBuf) -> Result<(), Box<dyn Error>> {
     handle_client(&mut reader, &mut writer)
 }
 
-fn launch(trace_folder: &Path, trace_file: &Path, seq: i64) -> Result<Handler, Box<dyn Error>> {
+fn launch(trace_folder: &Path, trace_file: &Path, raw_diff_index: Option<String>, seq: i64) -> Result<Handler, Box<dyn Error>> {
     // TODO: log this when logging logic is properly abstracted
     info!("run launch() for {:?}", trace_folder);
     let trace_file_format = if trace_file.extension() == Some(std::ffi::OsStr::new("json")) {
@@ -108,6 +108,7 @@ fn launch(trace_folder: &Path, trace_file: &Path, seq: i64) -> Result<Handler, B
 
         let mut handler = Handler::new(Box::new(db));
         handler.dap_client.seq = seq;
+        handler.raw_diff_index = raw_diff_index;
         handler.run_to_entry(dap::Request::default())?;
         Ok(handler)
     } else {
@@ -233,6 +234,7 @@ pub struct Ctx {
     pub received_launch: bool,
     pub launch_trace_folder: PathBuf,
     pub launch_trace_file: PathBuf,
+    pub launch_raw_diff_index: Option<String>,
     pub received_configuration_done: bool,
 }
 
@@ -245,6 +247,7 @@ impl Default for Ctx {
             received_launch: false,
             launch_trace_folder: PathBuf::from(""),
             launch_trace_file: PathBuf::from(""),
+            launch_raw_diff_index: None,
             received_configuration_done: false,
         }
     }
@@ -392,8 +395,10 @@ pub fn handle_message<T: DapTransport>(
                 // TODO: log this when logging logic is properly abstracted
                 //info!("stored launch trace folder: {0:?}", ctx.launch_trace_folder)
 
+                ctx.launch_raw_diff_index = args.raw_diff_index.clone();
+
                 if ctx.received_configuration_done {
-                    ctx.handler = Some(launch(&ctx.launch_trace_folder, &ctx.launch_trace_file, ctx.seq)?);
+                    ctx.handler = Some(launch(&ctx.launch_trace_folder, &ctx.launch_trace_file, ctx.launch_raw_diff_index.clone(), ctx.seq)?);
                     if let Some(h) = ctx.handler.as_mut() {
                         write_dap_messages(transport, h, &mut ctx.seq)?;
                     }
@@ -442,7 +447,7 @@ pub fn handle_message<T: DapTransport>(
             //     ctx.received_launch
             // );
             if ctx.received_launch {
-                ctx.handler = Some(launch(&ctx.launch_trace_folder, &ctx.launch_trace_file, ctx.seq)?);
+                ctx.handler = Some(launch(&ctx.launch_trace_folder, &ctx.launch_trace_file, ctx.launch_raw_diff_index.clone(), ctx.seq)?);
                 if let Some(h) = ctx.handler.as_mut() {
                     write_dap_messages(transport, h, &mut ctx.seq)?;
                 }

src/db-backend/src/diff.rs

@@ -67,6 +67,7 @@ pub struct DiffLine {
 
 // loop shape 1:
 pub fn load_and_postprocess_trace(trace_folder: &Path) -> Result<Db, Box<dyn Error>> {
+    info!("load_and_postprocess_trace {:?}", trace_folder.display());
     let mut trace_path = trace_folder.join("trace.json");
     let mut trace_file_format = runtime_tracing::TraceEventsFileFormat::Json;
     if !trace_path.exists() {
@@ -107,6 +108,7 @@ fn index_function_flow(_db: &Db, function_id: FunctionId) -> Result<(), Box<dyn
 
 
 pub fn index_diff(diff: Diff, trace_folder: &Path, multitrace_folder: &Path) -> Result<(), Box<dyn Error>> {
+    info!("index_diff");
     let db = load_and_postprocess_trace(trace_folder)?;
 
     // breakpoint on each diff line or at least track it for db-backend

src/db-backend/src/flow_preloader.rs

@@ -41,6 +41,7 @@ impl FlowPreloader {
     }
 
     pub fn load_diff_flow(&mut self, diff_lines: HashSet<(PathBuf, i64)>, db: &Db) -> FlowUpdate {
+        info!("load_diff_flow");
         for diff_line in &diff_lines {
             match self.expr_loader.load_file(&diff_line.0) {
                 Ok(_) => {

src/db-backend/src/main.rs

@@ -65,7 +65,7 @@ enum Commands {
         stdio: bool,
     },
     IndexDiff {
-        structured_diff_path: std::path::PathBuf,
+        structured_diff_raw: String, // _path: std::path::PathBuf,
         trace_folder: std::path::PathBuf,
         multitrace_folder: std::path::PathBuf,
     },
@@ -139,13 +139,13 @@ fn main() -> Result<(), Box<dyn Error>> {
             };
         }
         Commands::IndexDiff {
-            structured_diff_path,
+            structured_diff_raw,
             trace_folder,
             multitrace_folder,
         } => {
-            let raw = std::fs::read_to_string(structured_diff_path)?;
-            info!("raw {raw:?}");
-            let structured_diff = serde_json::from_str::<diff::Diff>(&raw)?;
+            // TODO: eventually structured diff path? big diff-s might not fit into CLI args
+            // let raw = std::fs::read_to_string(structured_diff_path)?;
+            let structured_diff = serde_json::from_str::<diff::Diff>(&structured_diff_raw)?;
             diff::index_diff(structured_diff, &trace_folder, &multitrace_folder)?;
         }
     }

src/db-backend/tests/dap_backend_server.rs

@@ -39,7 +39,6 @@ fn test_backend_dap_server() {
     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();
 
     if let Some(dir) = socket_path.parent() {
         fs::create_dir_all(dir).unwrap_or_else(|err| panic!("failed to create socket directory {dir:?}: {err}"));
@@ -63,7 +62,7 @@ fn test_backend_dap_server() {
     // use std::os::unix::fs::PermissionsExt;
     // fs::set_permissions(&socket_path, fs::Permissions::from_mode(0o600))?;
 
-    let mut child = Command::new(bin).arg(&socket_path).spawn().unwrap();
+    let mut child = Command::new(bin).arg("dap-server").arg(&socket_path).spawn().unwrap();
     println!("Bin: {}", bin);
 
     println!("Socket path: {}", socket_path.to_str().unwrap());