feat: work on experimetnal ct rr worker support: setup, communication

Author: alehander92

justfile

@@ -263,6 +263,7 @@ stop:
   killall -9 virtualization-layers db-backend node .electron-wrapped || true
   killall -9 electron || true
   killall -9 backend-manager || true
+  killall -9 ct-rr-worker || true
 
 reset-config:
   rm --force  ~/.config/codetracer/.config.yaml && \

src/common/config.nim

@@ -11,6 +11,7 @@ type
     path*:              string
     ctPaths*:           string
     debugInfoToolPath*: string
+    ctRRWorkerExe*:     string
 
   FlowConfigObjWrapper* = object
     enabled*:                             bool
@@ -63,7 +64,8 @@ type
       enabled: false,
       path: "",
       ctPaths: "",
-      debugInfoToolPath: ""
+      debugInfoToolPath: "",
+      ctRRWorkerExe: "",
     ).}:                                                  RRBackendConfig
     skipInstall:                                          bool
 

src/config/default_config.yaml

@@ -116,6 +116,7 @@ rrBackend:
   path: ""
   ctPaths: ""
   debugInfoToolPath: ""
+  ctRRWorkerExe: ""
 
 skipInstall: true
 

src/db-backend/src/bin/virtualization-layers.rs

@@ -21,6 +21,7 @@ extern crate db_backend;
 use db_backend::core::Core;
 use db_backend::db::Db;
 use db_backend::handler::{Handler, TraceKind};
+use db_backend::rr_dispatcher::CtRRArgs;
 // use db_backend::receiver::Receiver;
 // use db_backend::response::Response;
 
@@ -78,7 +79,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     let db = Db::new(&PathBuf::from(""));
     // receiver.setup_for_virtualization_layers(&cli.socket_path, cli.caller_process_pid)?;
 
-    let mut _handler = Handler::construct(TraceKind::DB, Box::new(db), true);
+    let mut _handler = Handler::construct(TraceKind::DB, CtRRArgs::default(), Box::new(db), true);
 
     // receiver.receive_loop(&mut handler)?;
 

src/db-backend/src/dap.rs

@@ -37,6 +37,8 @@ pub struct LaunchRequestArguments {
     pub trace_file: Option<PathBuf>,
     #[serde(rename = "rawDiffIndex", skip_serializing_if = "Option::is_none")]
     pub raw_diff_index: Option<String>,
+    #[serde(rename = "ctRRWorkerExe", skip_serializing_if = "Option::is_none")]
+    pub ct_rr_worker_exe: Option<PathBuf>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub pid: Option<u64>,
     #[serde(skip_serializing_if = "Option::is_none")]

src/db-backend/src/dap_server.rs

@@ -4,6 +4,7 @@ use crate::dap_types::{self, Breakpoint, SetBreakpointsArguments, SetBreakpoints
 use crate::db::Db;
 use crate::handler::{Handler, TraceKind};
 use crate::paths::CODETRACER_PATHS;
+use crate::rr_dispatcher::CtRRArgs;
 use crate::task::{
     gen_task_id, Action, CallSearchArg, CalltraceLoadArgs, CollapseCallsArgs, CtLoadFlowArguments,
     CtLoadLocalsArguments, FunctionLocation, LoadHistoryArg, LocalStepJump, Location, ProgramEvent, RunTracepointsArg,
@@ -17,7 +18,7 @@ use crate::transport::DapTransport;
 #[cfg(feature = "browser-transport")]
 use crate::transport::{DapResult, WorkerTransport};
 
-use log::info;
+use log::{info, warn};
 use serde_json::json;
 use std::collections::{HashMap, HashSet};
 use std::error::Error;
@@ -86,8 +87,13 @@ pub fn run(socket_path: &PathBuf) -> Result<(), Box<dyn Error>> {
     handle_client(&mut reader, &mut writer)
 }
 
-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
+fn launch(
+    trace_folder: &Path,
+    trace_file: &Path,
+    raw_diff_index: Option<String>,
+    ct_rr_worker_exe: &Path,
+    seq: i64,
+) -> Result<Handler, Box<dyn Error>> {
     info!("run launch() for {:?}", trace_folder);
     let trace_file_format = if trace_file.extension() == Some(std::ffi::OsStr::new("json")) {
         runtime_tracing::TraceEventsFileFormat::Json
@@ -106,18 +112,23 @@ fn launch(trace_folder: &Path, trace_file: &Path, raw_diff_index: Option<String>
         let mut proc = TraceProcessor::new(&mut db);
         proc.postprocess(&trace)?;
 
-        let mut handler = Handler::new(TraceKind::DB, Box::new(db));
+        let mut handler = Handler::new(TraceKind::DB, CtRRArgs::default(), 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 {
         warn!("problem with reading metadata or path trace files: try rr?");
-        let path  = trace_folder.join("rr");
+        let path = trace_folder.join("rr").join("latest-trace");
         if path.exists() {
-            let db = Db::new(&PathBuf::from("")); 
-            let mut handler = Handler::new(TraceKind::RR, Box::new(db));
+            let db = Db::new(&PathBuf::from(""));
+            let ct_rr_args = CtRRArgs {
+                worker_exe: PathBuf::from(ct_rr_worker_exe),
+                rr_trace_folder: path,
+            };
+            let mut handler = Handler::new(TraceKind::RR, ct_rr_args, 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 {
@@ -245,6 +256,7 @@ pub struct Ctx {
     pub launch_trace_folder: PathBuf,
     pub launch_trace_file: PathBuf,
     pub launch_raw_diff_index: Option<String>,
+    pub ct_rr_worker_exe: PathBuf,
     pub received_configuration_done: bool,
 }
 
@@ -258,6 +270,7 @@ impl Default for Ctx {
             launch_trace_folder: PathBuf::from(""),
             launch_trace_file: PathBuf::from(""),
             launch_raw_diff_index: None,
+            ct_rr_worker_exe: PathBuf::from(""),
             received_configuration_done: false,
         }
     }
@@ -406,9 +419,15 @@ pub fn handle_message<T: DapTransport>(
                 //info!("stored launch trace folder: {0:?}", ctx.launch_trace_folder)
 
                 ctx.launch_raw_diff_index = args.raw_diff_index.clone();
+                ctx.ct_rr_worker_exe = args.ct_rr_worker_exe.unwrap_or(PathBuf::from(""));
 
                 if ctx.received_configuration_done {
-                    ctx.handler = Some(launch(&ctx.launch_trace_folder, &ctx.launch_trace_file, ctx.launch_raw_diff_index.clone(), ctx.seq)?);
+                    ctx.handler = Some(launch(
+                        &ctx.launch_trace_folder,
+                        &ctx.launch_trace_file,
+                        ctx.launch_raw_diff_index.clone(),
+                        &ctx.ct_rr_worker_exe,
+                        ctx.seq)?);
                     if let Some(h) = ctx.handler.as_mut() {
                         write_dap_messages(transport, h, &mut ctx.seq)?;
                     }
@@ -457,7 +476,12 @@ 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.launch_raw_diff_index.clone(), ctx.seq)?);
+                ctx.handler = Some(launch(
+                    &ctx.launch_trace_folder,
+                    &ctx.launch_trace_file,
+                    ctx.launch_raw_diff_index.clone(),
+                    &ctx.ct_rr_worker_exe,
+                    ctx.seq)?);
                 if let Some(h) = ctx.handler.as_mut() {
                     write_dap_messages(transport, h, &mut ctx.seq)?;
                 }

src/db-backend/src/handler.rs

@@ -15,7 +15,7 @@ use crate::event_db::{EventDb, SingleTableId};
 use crate::expr_loader::ExprLoader;
 use crate::flow_preloader::FlowPreloader;
 use crate::program_search_tool::ProgramSearchTool;
-use crate::rr_dispatcher::{RRDispatcher};
+use crate::rr_dispatcher::{CtRRArgs, RRDispatcher};
 // use crate::response::{};
 use crate::dap_types;
 // use crate::dap_types::Source;
@@ -60,10 +60,9 @@ pub struct Handler {
 #[derive(Debug, Clone)]
 pub enum TraceKind {
     DB,
-    RR
+    RR,
 }
 
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BreakpointRecord {
     pub is_active: bool,
@@ -90,11 +89,11 @@ type LineTraceMap = HashMap<usize, Vec<(usize, String)>>;
 //   sender.
 
 impl Handler {
-    pub fn new(trace_kind: TraceKind, db: Box<Db>) -> Handler {
-        Self::construct(trace_kind, db, false)
+    pub fn new(trace_kind: TraceKind, ct_rr_args: CtRRArgs, db: Box<Db>) -> Handler {
+        Self::construct(trace_kind, ct_rr_args, db, false)
     }
 
-    pub fn construct(trace_kind: TraceKind, db: Box<Db>, indirect_send: bool) -> Handler {
+    pub fn construct(trace_kind: TraceKind, ct_rr_args: CtRRArgs, db: Box<Db>, indirect_send: bool) -> Handler {
         let calltrace = Calltrace::new(&db);
         let trace = CoreTrace::default();
         let mut expr_loader = ExprLoader::new(trace.clone());
@@ -118,7 +117,7 @@ impl Handler {
             step_lines_loader,
             dap_client: DapClient::default(),
             previous_step_id: StepId(0),
-            rr: RRDispatcher::new(),
+            rr: RRDispatcher::new(ct_rr_args),
             resulting_dap_messages: vec![],
             raw_diff_index: None,
         }
@@ -288,10 +287,10 @@ impl Handler {
         match self.trace_kind {
             TraceKind::DB => {
                 self.step_id_jump(StepId(0));
-            },
+            }
             TraceKind::RR => {
                 self.rr.run_to_entry()?;
-            },
+            }
         }
         self.complete_move(true)?;
         Ok(())

src/db-backend/src/lib.rs

@@ -30,15 +30,16 @@ pub mod dap_error;
 pub mod dap_server;
 pub mod dap_types;
 pub mod db;
-pub mod distinct_vec;
 pub mod diff;
+pub mod distinct_vec;
 pub mod event_db;
 pub mod expr_loader;
 pub mod flow_preloader;
 pub mod handler;
 pub mod lang;
 pub mod paths;
 pub mod program_search_tool;
+pub mod query;
 pub mod rr_dispatcher;
 pub mod step_lines_loader;
 pub mod task;

src/db-backend/src/main.rs

@@ -38,6 +38,7 @@ mod handler;
 mod lang;
 mod paths;
 mod program_search_tool;
+mod query;
 mod rr_dispatcher;
 mod step_lines_loader;
 mod task;

src/db-backend/src/query.rs

@@ -0,0 +1,7 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "kind")]
+pub enum CtRRQuery {
+    RunToEntry,
+}