fix: for now make it run with noop for some tasks; add more methods for Replay

Author: alehander92

src/db-backend/src/db.rs

@@ -14,8 +14,8 @@ use runtime_tracing::{
 use crate::distinct_vec::DistinctVec;
 use crate::expr_loader::ExprLoader;
 use crate::lang::Lang;
-use crate::replay::Replay;
-use crate::task::{Call, CallArg, Location, RRTicks, NO_INDEX};
+use crate::replay::{Events, Replay};
+use crate::task::{Call, CallArg, Location, ProgramEvent, RRTicks, NO_INDEX, NO_PATH, NO_POSITION};
 use crate::value::{Type, Value};
 
 const NEXT_INTERNAL_STEP_OVERS_LIMIT: usize = 1_000;
@@ -789,6 +789,67 @@ impl DbReplay {
             self.step_id = step_id;
         }
     }
+
+    fn to_program_event(&self, event_record: &DbRecordEvent, index: usize) -> ProgramEvent {
+        let step_id_int = event_record.step_id.0;
+        let (path, line) = if step_id_int != NO_INDEX {
+            let step_record = &self.db.steps[event_record.step_id];
+            (
+                self.db
+                    .workdir
+                    .join(self.db.load_path_from_id(&step_record.path_id))
+                    .display()
+                    .to_string(),
+                step_record.line.0,
+            )
+        } else {
+            (NO_PATH.to_string(), NO_POSITION)
+        };
+
+        ProgramEvent {
+            kind: event_record.kind,
+            content: event_record.content.clone(),
+            bytes: event_record.content.len(),
+            rr_event_id: index,
+            direct_location_rr_ticks: step_id_int,
+            metadata: event_record.metadata.to_string(),
+            stdout: true,
+            event_index: index,
+            tracepoint_result_index: NO_INDEX,
+            high_level_path: path,
+            high_level_line: line,
+            base64_encoded: false,
+            max_rr_ticks: self
+                .db
+                .steps
+                .last()
+                .unwrap_or(&DbStep {
+                    step_id: StepId(0),
+                    path_id: PathId(0),
+                    line: Line(0),
+                    call_key: CallKey(0),
+                    global_call_key: CallKey(0),
+                })
+                .step_id
+                .0,
+        }
+    }
+
+    fn single_step_line(&self, step_index: usize, forward: bool) -> usize {
+        // taking note of db.lines limits: returning a valid step id always
+        if forward {
+            if step_index < self.db.steps.len() - 1 {
+                step_index + 1
+            } else {
+                step_index
+            }
+        } else if step_index > 0 {
+            step_index - 1
+        } else {
+            // auto-returning the same 0 if stepping backwards from 0
+            step_index
+        }
+    }
 }
 
 impl Replay for DbReplay {
@@ -802,4 +863,35 @@ impl Replay for DbReplay {
         self.step_id_jump(StepId(0));
         Ok(())
     }
+
+    fn load_events(&mut self) -> Result<Events, Box<dyn Error>> {
+        let mut events: Vec<ProgramEvent> = vec![];
+        let mut first_events: Vec<ProgramEvent> = vec![];
+        let mut contents: String = "".to_string();
+
+        for (i, event_record) in self.db.events.iter().enumerate() {
+            let mut event = self.to_program_event(event_record, i);
+            event.content = event_record.content.to_string();
+            events.push(event.clone());
+            if i < 20 {
+                first_events.push(event);
+                contents.push_str(&format!("{}\\n\n", event_record.content));
+            }
+        }
+
+        Ok(Events {
+            events,
+            first_events,
+            contents,
+        })
+    }
+
+    fn step_in(&mut self, forward: bool) -> Result<(), Box<dyn Error>> {
+        self.step_id = StepId(self.single_step_line(self.step_id.0 as usize, forward) as i64);
+        Ok(())
+    }
+
+    fn current_step_id(&self) -> StepId {
+        self.step_id
+    }
 }

src/db-backend/src/handler.rs

@@ -339,6 +339,13 @@ impl Handler {
     }
 
     pub fn load_locals(&mut self, req: dap::Request, _args: task::CtLoadLocalsArguments) -> Result<(), Box<dyn Error>> {
+        if self.trace_kind == TraceKind::RR {
+            let locals: Vec<Variable> = vec![];
+            warn!("load_locals not implemented for rr yet");
+            self.respond_dap(req, task::CtLoadLocalsResponseBody { locals })?;
+            return Ok(());
+        }
+
         let full_value_locals: Vec<Variable> = self.db.variables[self.step_id]
             .iter()
             .map(|v| Variable {
@@ -448,6 +455,11 @@ impl Handler {
         _req: dap::Request,
         args: CalltraceLoadArgs,
     ) -> Result<(), Box<dyn Error>> {
+        if self.trace_kind == TraceKind::RR {
+            warn!("load_calltrace_section not implemented for rr");
+            return Ok(());
+        }
+
         let start_call_line_index = args.start_call_line_index;
         let call_lines = self.load_local_calltrace(args)?;
         let total_count = self.calc_total_calls();
@@ -466,6 +478,19 @@ impl Handler {
     }
 
     pub fn load_flow(&mut self, _req: dap::Request, arg: CtLoadFlowArguments) -> Result<(), Box<dyn Error>> {
+        if self.trace_kind == TraceKind::RR {
+            warn!("flow not implemented for rr");
+            return Ok(());
+        }
+        // TODO: something like this for db/rr:
+        // {
+        // // TODO: pass step_id to load_location and let it jump for RR if needed?
+        // // or have a separate jump_to when it's not self.step_id?
+        // self.replay.jump_to(step_id)?;
+        // let location = self.replay.load_location(&mut self.expr_loader)?;
+        // let flow_update = self.flow_preloader.load(location, FlowMode::Call, &self.replay);
+        // }
+
         let flow_update = if arg.flow_mode == FlowMode::Call {
             let step_id = StepId(arg.location.rr_ticks.0);
             let call_key = self.db.steps[step_id].call_key;
@@ -538,7 +563,9 @@ impl Handler {
     }
 
     pub fn step_in(&mut self, forward: bool) -> Result<(), Box<dyn Error>> {
-        self.step_id = StepId(self.single_step_line(self.step_id.0 as usize, forward) as i64);
+        self.replay.step_in(forward)?;
+        self.step_id = self.replay.current_step_id();
+
         Ok(())
     }
 
@@ -670,19 +697,11 @@ impl Handler {
     }
 
     pub fn event_load(&mut self, _req: dap::Request) -> Result<(), Box<dyn Error>> {
-        let mut events: Vec<ProgramEvent> = vec![];
-        let mut first_events: Vec<ProgramEvent> = vec![];
-        let mut contents: String = "".to_string();
+        let events_data = self.replay.load_events()?;
 
-        for (i, event_record) in self.db.events.iter().enumerate() {
-            let mut event = self.to_program_event(event_record, i);
-            event.content = event_record.content.to_string();
-            events.push(event.clone());
-            if i < 20 {
-                first_events.push(event);
-                contents.push_str(&format!("{}\\n\n", event_record.content));
-            }
-        }
+        let events = events_data.events;
+        let first_events = events_data.first_events;
+        let contents = events_data.contents;
 
         self.event_db.register_events(DbEventKind::Record, &events, vec![-1]);
         self.event_db.refresh_global();

src/db-backend/src/replay.rs

@@ -1,9 +1,20 @@
+use runtime_tracing::StepId;
 use std::error::Error;
 
 use crate::expr_loader::ExprLoader;
-use crate::task::Location;
+use crate::task::{Location, ProgramEvent};
+
+#[derive(Debug, Clone)]
+pub struct Events {
+    pub events: Vec<ProgramEvent>,
+    pub first_events: Vec<ProgramEvent>,
+    pub contents: String,
+}
 
 pub trait Replay: std::fmt::Debug {
     fn load_location(&mut self, expr_loader: &mut ExprLoader) -> Result<Location, Box<dyn Error>>;
     fn run_to_entry(&mut self) -> Result<(), Box<dyn Error>>;
+    fn load_events(&mut self) -> Result<Events, Box<dyn Error>>;
+    fn step_in(&mut self, forward: bool) -> Result<(), Box<dyn Error>>;
+    fn current_step_id(&self) -> StepId;
 }

src/db-backend/src/rr_dispatcher.rs

@@ -7,12 +7,13 @@ use std::process::{Child, Command, Stdio};
 use std::thread;
 use std::time::Duration;
 
-use log::info;
+use log::{info, warn};
+use runtime_tracing::StepId;
 
 use crate::expr_loader::ExprLoader;
 use crate::paths::ct_rr_worker_socket_path;
 use crate::query::CtRRQuery;
-use crate::replay::Replay;
+use crate::replay::{Events, Replay};
 use crate::task::Location;
 
 #[derive(Debug)]
@@ -157,4 +158,24 @@ impl Replay for RRDispatcher {
         let _ok = self.stable.run_query(CtRRQuery::RunToEntry)?;
         Ok(())
     }
+
+    fn load_events(&mut self) -> Result<Events, Box<dyn Error>> {
+        self.ensure_active_stable()?;
+        warn!("TODO load_events rr");
+        Ok(Events {
+            events: vec![],
+            first_events: vec![],
+            contents: "".to_string(),
+        })
+    }
+
+    fn step_in(&mut self, forward: bool) -> Result<(), Box<dyn Error>> {
+        todo!()
+    }
+
+    fn current_step_id(&self) -> StepId {
+        // cache location or step_id and return
+        // OR always load from worker
+        todo!()
+    }
 }