Nested Parsers: Separate parsing in sessions and CLI

* Sessions needs to keep track on errors but indexer CLI doesn't need
  that for now.
* Each part should responsible of how errors for parsing log messages
  should be handled.
* Added reminder for handling resolver in indexer CLI.

Author: AmmarAbouZor

application/apps/indexer/indexer_cli/src/interactive.rs

@@ -1,9 +1,8 @@
 use crate::{duration_report, Instant};
 use futures::{pin_mut, stream::StreamExt};
 use parsers::{
-    dlt::DltParser,
-    nested_parser::{resolve_log_msg, ParseRestResolver},
-    MessageStreamItem, ParseYield,
+    dlt::DltParser, nested_parser::ParseRestResolver, LogMessage, MessageStreamItem,
+    ParseLogMsgError, ParseYield,
 };
 use processor::grabber::LineRange;
 use rustyline::{error::ReadlineError, DefaultEditor};
@@ -50,6 +49,7 @@ pub(crate) async fn handle_interactive_session(input: Option<PathBuf>) {
                             let udp_source = UdpSource::new(RECEIVER, vec![]).await.unwrap();
                             let dlt_parser = DltParser::new(None, None, None, false);
                             let mut dlt_msg_producer = MessageProducer::new(dlt_parser, udp_source, None);
+                            //TODO AAZ: Make sure we need to provide the resolver in indexer CLI.
                             let mut parse_reslover = ParseRestResolver::new();
                             let msg_stream = dlt_msg_producer.as_stream();
                             pin_mut!(msg_stream);
@@ -62,11 +62,11 @@ pub(crate) async fn handle_interactive_session(input: Option<PathBuf>) {
                                     item = msg_stream.next() => {
                                         match item {
                                             Some((_, MessageStreamItem::Item(ParseYield::Message(item)))) => {
-                                                let msg = resolve_log_msg(item, &mut parse_reslover);
+                                                let msg = parse_log_msg_lossy(item, &mut parse_reslover);
                                                 println!("msg: {msg}");
                                             }
                                             Some((_, MessageStreamItem::Item(ParseYield::MessageAndAttachment((item, attachment))))) => {
-                                                let msg = resolve_log_msg(item, &mut parse_reslover);
+                                                let msg = parse_log_msg_lossy(item, &mut parse_reslover);
                                                 println!("msg: {msg}, attachment: {attachment:?}");
                                             }
                                             Some((_, MessageStreamItem::Item(ParseYield::Attachment(attachment)))) => {
@@ -201,3 +201,11 @@ async fn collect_user_input(tx: mpsc::UnboundedSender<Command>) -> JoinHandle<()
         println!("done with readline loop");
     })
 }
+
+/// Parse log messages without registering errors and calling [`ParseLogMsgError::parse_lossy()`] on errors
+pub fn parse_log_msg_lossy<T: LogMessage>(item: T, err_resolver: &mut ParseRestResolver) -> String {
+    match item.try_resolve(Some(err_resolver)) {
+        Ok(item) => item.to_string(),
+        Err(err) => err.parse_lossy(),
+    }
+}

application/apps/indexer/parsers/src/nested_parser.rs

@@ -75,16 +75,3 @@ impl ParseRestResolver {
 
 // Ensure the type of given argument is Infallible, raising a compile time error if not.
 fn ensure_infalliable(_err: Infallible) {}
-
-/// Get the text message of [`LogMessage`], resolving its rest payloads if existed when possible,
-/// TODO: Otherwise it should save the error to the faulty messages store, which need to be
-/// implemented as well :)
-pub fn resolve_log_msg<T: LogMessage>(item: T, err_resolver: &mut ParseRestResolver) -> String {
-    match item.try_resolve(Some(err_resolver)) {
-        Ok(item) => item.to_string(),
-        Err(err) => {
-            //TODO: Add error to errors cache.
-            err.parse_lossy()
-        }
-    }
-}

application/apps/indexer/session/src/handlers/observing/mod.rs

@@ -8,10 +8,10 @@ use crate::{
 use log::trace;
 use parsers::{
     dlt::{fmt::FormatOptions, DltParser},
-    nested_parser::{resolve_log_msg, ParseRestResolver},
+    nested_parser::ParseRestResolver,
     someip::SomeipParser,
     text::StringTokenizer,
-    LogMessage, MessageStreamItem, ParseYield, Parser,
+    LogMessage, MessageStreamItem, ParseLogMsgError, ParseYield, Parser,
 };
 use sources::{
     factory::ParserType,
@@ -240,3 +240,16 @@ async fn run_producer<T: LogMessage, P: Parser<T>, S: ByteSource>(
     debug!("listen done");
     Ok(None)
 }
+
+/// Get the text message of [`LogMessage`], resolving its rest payloads if existed when possible,
+/// TODO: Otherwise it should save the error to the faulty messages store, which need to be
+/// implemented as well :)
+pub fn resolve_log_msg<T: LogMessage>(item: T, err_resolver: &mut ParseRestResolver) -> String {
+    match item.try_resolve(Some(err_resolver)) {
+        Ok(item) => item.to_string(),
+        Err(err) => {
+            //TODO: Add error to errors cache.
+            err.parse_lossy()
+        }
+    }
+}