Reduce log chatter

archapp/src/archeng.rs

@@ -118,7 +118,7 @@ pub fn list_all_channels(node: &ChannelArchiver) -> Receiver<Result<ListChannelI
             while let Some(item) = rx.next().await {
                 match item {
                     Ok(StreamItem::Stats(item)) => {
-                        info!("stats: {:?}", item);
+                        debug!("stats: {:?}", item);
                     }
                     _ => {}
                 }
@@ -179,9 +179,7 @@ pub async fn channel_config(q: &ChannelConfigQuery, conf: &ChannelArchiver) -> R
                     }
                 }
                 JsVal(jsval) => {
-                    if true {
-                        info!("jsval: {}", serde_json::to_string(&jsval)?);
-                    }
+                    debug!("jsval: {}", serde_json::to_string(&jsval)?);
                 }
             },
             Err(e) => {
@@ -208,9 +206,7 @@ pub async fn channel_config(q: &ChannelConfigQuery, conf: &ChannelArchiver) -> R
                         }
                     }
                     JsVal(jsval) => {
-                        if true {
-                            info!("jsval: {}", serde_json::to_string(&jsval)?);
-                        }
+                        debug!("jsval: {}", serde_json::to_string(&jsval)?);
                     }
                 },
                 Err(e) => {
@@ -285,7 +281,8 @@ mod test {
             let mut data_file = open_read(data_path, stats).await?;
             let datafile_header = read_datafile_header(&mut data_file, datablock.data_header_pos(), stats).await?;
             let events = read_data_1(&mut data_file, &datafile_header, range.clone(), false, stats).await?;
-            info!("read events: {:?}", events);
+            debug!("read events: {:?}", events);
+            // TODO assert more
             Ok(())
         };
         Ok(taskrun::run(fut).unwrap())

archapp/src/archeng/datablock.rs

@@ -513,7 +513,7 @@ pub async fn read_data_1(
                         evs.values.push(value);
                     }
                 }
-                info!("parsed block with {} / {} events", ntot, evs.tss.len());
+                debug!("parsed block with {} / {} events", ntot, evs.tss.len());
                 let evs = ScalarPlainEvents::Double(evs);
                 let plain = PlainEvents::Scalar(evs);
                 let item = EventsItem::Plain(plain);

archapp/src/archeng/datablockstream.rs

@@ -322,9 +322,9 @@ mod test {
     use futures_util::StreamExt;
     use items::eventsitem::EventsItem;
     use items::{LogItem, Sitemty, StatsItem, StreamItem};
+    use netpod::log::*;
     use netpod::timeunits::SEC;
-    use netpod::{log::*, RangeFilterStats};
-    use netpod::{Channel, NanoRange};
+    use netpod::{Channel, NanoRange, RangeFilterStats};
     use serde::Serialize;
     use std::collections::VecDeque;
     use std::path::PathBuf;
@@ -358,7 +358,12 @@ mod test {
             let filtered = RangeFilter::<_, EventsItem>::new(datablocks, range, expand);
             let mut stream = filtered;
             while let Some(block) = stream.next().await {
-                info!("DatablockStream yields: {:?}", block);
+                match block {
+                    Ok(_) => {
+                        //TODO assert more
+                    }
+                    Err(e) => return Err(e),
+                }
             }
             Ok(())
         };

archapp/src/archeng/indexfiles.rs

@@ -544,7 +544,13 @@ pub async fn index_files_index_ref<P: Into<PathBuf> + Send>(
             let index_files_index_path = index_files_index_path.into();
             let index_files_index = {
                 let timed1 = Timed::new("slurp_index_bytes");
-                let mut index_files_index = open_read(index_files_index_path, stats).await?;
+                let mut index_files_index = match open_read(index_files_index_path.clone(), stats).await {
+                    Ok(k) => Ok(k),
+                    Err(e) => {
+                        warn!("can not open indexfile {:?}", index_files_index_path);
+                        Err(e)
+                    }
+                }?;
                 let mut buf = vec![0; 1024 * 1024 * 50];
                 let mut ntot = 0;
                 loop {

archapp/src/archeng/indextree.rs

@@ -125,7 +125,6 @@ impl IndexFileBasics {
                     rb.fill_min(min0).await?;
                     let buf = rb.data();
                     let entry = parse_name_hash_channel_entry(buf, self.hver.as_ref())?;
-                    info!("parsed entry {:?}", entry);
                     pos = entry.next;
                     entries.push(entry);
                 }
@@ -1155,7 +1154,8 @@ mod test {
             let mut i1 = 0;
             let mut ts_max = Nanos::from_ns(0);
             while let Some(rec) = iter.next().await? {
-                info!("GOT RECORD: {:?}  {:?}", rec.beg, rec.target);
+                // TODO assert
+                debug!("GOT RECORD: {:?}  {:?}", rec.beg, rec.target);
                 if rec.beg <= ts_max {
                     return Err(Error::with_msg_no_trace("BAD ORDER"));
                 }

archapp/src/test.rs

@@ -23,6 +23,7 @@ fn read_pb_00() -> Result<(), Error> {
             .join("X:2021_01.pb");
         let f1 = tokio::fs::read(path).await?;
         let mut j1 = 0;
+        // TODO assert more
         loop {
             let mut i2 = usize::MAX;
             for (i1, &k) in f1[j1..].iter().enumerate() {
@@ -32,17 +33,17 @@ fn read_pb_00() -> Result<(), Error> {
                 }
             }
             if i2 != usize::MAX {
-                info!("got NL  {} .. {}", j1, i2);
+                debug!("got NL  {} .. {}", j1, i2);
                 let m = unescape_archapp_msg(&f1[j1..i2], vec![])?;
                 if j1 == 0 {
                     let payload_info = crate::generated::EPICSEvent::PayloadInfo::parse_from_bytes(&m).unwrap();
-                    info!("got payload_info: {:?}", payload_info);
+                    debug!("got payload_info: {:?}", payload_info);
                 } else {
                     let scalar_double = crate::generated::EPICSEvent::ScalarDouble::parse_from_bytes(&m).unwrap();
-                    info!("got scalar_double: {:?}", scalar_double);
+                    debug!("got scalar_double: {:?}", scalar_double);
                 }
             } else {
-                info!("no more packets");
+                debug!("no more packets");
                 break;
             }
             j1 = i2 + 1;

archapp/src/timed.rs

@@ -23,6 +23,6 @@ impl Drop for Timed {
     fn drop(&mut self) {
         let ts2 = Instant::now();
         let dt = ts2.duration_since(self.ts1);
-        info!("Timed {} {:?}", self.name, dt);
+        debug!("Timed {} {:?}", self.name, dt);
     }
 }