feat: start prototyping experimental rr with db backend: TODO rr process

Author: alehander92

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

@@ -20,7 +20,7 @@ use std::path::PathBuf;
 extern crate db_backend;
 use db_backend::core::Core;
 use db_backend::db::Db;
-use db_backend::handler::Handler;
+use db_backend::handler::{Handler, TraceKind};
 // use db_backend::receiver::Receiver;
 // use db_backend::response::Response;
 
@@ -78,7 +78,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(Box::new(db), true);
+    let mut _handler = Handler::construct(TraceKind::DB, Box::new(db), true);
 
     // receiver.receive_loop(&mut handler)?;
 

src/db-backend/src/dap_server.rs

@@ -2,7 +2,7 @@ use crate::dap::{self, Capabilities, DapMessage, Event, ProtocolMessage, Respons
 use crate::dap_types::{self, Breakpoint, SetBreakpointsArguments, SetBreakpointsResponseBody, Source};
 
 use crate::db::Db;
-use crate::handler::Handler;
+use crate::handler::{Handler, TraceKind};
 use crate::paths::CODETRACER_PATHS;
 use crate::task::{
     gen_task_id, Action, CallSearchArg, CalltraceLoadArgs, CollapseCallsArgs, CtLoadFlowArguments,
@@ -106,13 +106,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(Box::new(db));
+        let mut handler = Handler::new(TraceKind::DB, 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 {
-        Err("problem with reading metadata or path trace files".into())
+        warn!("problem with reading metadata or path trace files: try rr?");
+        let path  = trace_folder.join("rr");
+        if path.exists() {
+            let db = Db::new(&PathBuf::from("")); 
+            let mut handler = Handler::new(TraceKind::RR, Box::new(db));
+            handler.dap_client.seq = seq;
+            handler.run_to_entry(dap::Request::default())?;
+            Ok(handler)
+        } else {
+            Err("problem with reading metadata or path trace files".into())
+        }
     }
 }
 

src/db-backend/src/handler.rs

@@ -15,6 +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::response::{};
 use crate::dap_types;
 // use crate::dap_types::Source;
@@ -51,9 +52,18 @@ pub struct Handler {
     pub raw_diff_index: Option<String>,
     pub previous_step_id: StepId,
 
+    pub trace_kind: TraceKind,
+    pub rr: RRDispatcher,
     pub breakpoint_list: Vec<HashMap<usize, BreakpointRecord>>,
 }
 
+#[derive(Debug, Clone)]
+pub enum TraceKind {
+    DB,
+    RR
+}
+
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BreakpointRecord {
     pub is_active: bool,
@@ -80,11 +90,11 @@ type LineTraceMap = HashMap<usize, Vec<(usize, String)>>;
 //   sender.
 
 impl Handler {
-    pub fn new(db: Box<Db>) -> Handler {
-        Self::construct(db, false)
+    pub fn new(trace_kind: TraceKind, db: Box<Db>) -> Handler {
+        Self::construct(trace_kind, db, false)
     }
 
-    pub fn construct(db: Box<Db>, indirect_send: bool) -> Handler {
+    pub fn construct(trace_kind: TraceKind, db: Box<Db>, indirect_send: bool) -> Handler {
         let calltrace = Calltrace::new(&db);
         let trace = CoreTrace::default();
         let mut expr_loader = ExprLoader::new(trace.clone());
@@ -93,6 +103,7 @@ impl Handler {
         let step_lines_loader = StepLinesLoader::new(&db, &mut expr_loader);
         // let sender = sender::Sender::new();
         Handler {
+            trace_kind,
             db,
             step_id: StepId(0),
             last_call_key: CallKey(0),
@@ -107,6 +118,7 @@ impl Handler {
             step_lines_loader,
             dap_client: DapClient::default(),
             previous_step_id: StepId(0),
+            rr: RRDispatcher::new(),
             resulting_dap_messages: vec![],
             raw_diff_index: None,
         }
@@ -273,7 +285,14 @@ impl Handler {
     }
 
     pub fn run_to_entry(&mut self, _req: dap::Request) -> Result<(), Box<dyn Error>> {
-        self.step_id_jump(StepId(0));
+        match self.trace_kind {
+            TraceKind::DB => {
+                self.step_id_jump(StepId(0));
+            },
+            TraceKind::RR => {
+                self.rr.run_to_entry()?;
+            },
+        }
         self.complete_move(true)?;
         Ok(())
     }
@@ -1814,6 +1833,7 @@ mod tests {
         }
         let trace_metadata_file = path.join("trace_metadata.json");
         let trace = load_trace_data(&trace_file, trace_file_format).expect("expected that it can load the trace file");
+        info!("trace {:?}", trace);
         let trace_metadata =
             load_trace_metadata(&trace_metadata_file).expect("expected that it can load the trace metadata file");
         let mut db = Db::new(&trace_metadata.workdir);

src/db-backend/src/lib.rs

@@ -39,6 +39,7 @@ pub mod handler;
 pub mod lang;
 pub mod paths;
 pub mod program_search_tool;
+pub mod rr_dispatcher;
 pub mod step_lines_loader;
 pub mod task;
 pub mod trace_processor;

src/db-backend/src/main.rs

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

src/db-backend/src/rr_dispatcher.rs

@@ -0,0 +1,45 @@
+use std::error::Error;
+
+#[derive(Debug, Clone)]
+pub struct RRDispatcher {
+    pub stable: RRProcess,
+}
+
+#[derive(Debug, Clone)]
+pub struct RRProcess {
+    pub name: String,
+    pub active: bool,
+    // TODO: os process,sockets? ipc?, other metadata
+}
+
+impl RRDispatcher {
+    pub fn new() -> RRDispatcher {
+        RRDispatcher { 
+            stable: RRProcess::new("stable"),
+        }
+    }
+
+    pub fn run_to_entry(&mut self) -> Result<(), Box<dyn Error>> {
+        self.ensure_active_stable()?;
+        self.stable.run_to_entry()
+    }
+
+    pub fn ensure_active_stable(&mut self) -> Result<(), Box<dyn Error>> {
+        todo!() // start stable process if not active, store fields, setup ipc? store in stable
+    }
+}
+
+impl RRProcess {
+    pub fn new(name: &str) -> RRProcess {
+        RRProcess {
+            name: name.to_string(),
+            active: false,
+        }
+    }
+
+    pub fn run_to_entry(&mut self) -> Result<(), Box<dyn Error>> {
+        // send to process or directly run `start` / similar low level commands
+        // load / update location ? (or leave this for later?)
+        todo!()
+    }
+}

src/db-backend/src/trace_processor.rs

@@ -450,7 +450,7 @@ pub fn load_trace_data(
 pub fn load_trace_metadata(trace_metadata_file: &Path) -> Result<TraceMetadata, Box<dyn Error>> {
     // copied and adapted from https://stackoverflow.com/a/70926549/438099
     let path = expanduser(trace_metadata_file.display().to_string())?;
-    let raw_bytes = fs::read(&path).unwrap_or_else(|_| panic!("metadata file {path:?} read error"));
+    let raw_bytes = fs::read(&path)?; //.unwrap_or_else(|_| panic!("metadata file {path:?} read error"));
     let raw = str::from_utf8(&raw_bytes)?;
 
     let trace_metadata: TraceMetadata = serde_json::from_str(raw)?;