First basic plain event fetch as binary

disk/src/binned/pbv.rs

@@ -6,7 +6,7 @@ use crate::binned::{EventsNodeProcessor, NumOps, PushableIndex, RangeCompletable
 use crate::cache::{write_pb_cache_min_max_avg_scalar, CacheFileDesc, WrittenPbCache};
 use crate::decode::{Endianness, EventValueFromBytes, EventValueShape, NumFromBytes};
 use crate::frame::makeframe::FrameType;
-use crate::merge::mergedfromremotes::MergedFromRemotes2;
+use crate::merge::mergedfromremotes::MergedFromRemotes;
 use crate::raw::EventsQuery;
 use crate::streamlog::Streamlog;
 use crate::Sitemty;
@@ -123,7 +123,7 @@ where
         let range = BinnedRange::covering_range(evq.range.clone(), count as u32)?
             .ok_or(Error::with_msg("covering_range returns None"))?;
         let perf_opts = PerfOpts { inmem_bufcap: 512 };
-        let s = MergedFromRemotes2::<ENP>::new(evq, perf_opts, self.node_config.node_config.cluster.clone());
+        let s = MergedFromRemotes::<ENP>::new(evq, perf_opts, self.node_config.node_config.cluster.clone());
         let ret = TBinnerStream::<_, <ENP as EventsNodeProcessor>::Output>::new(s, range);
         Ok(Box::pin(ret))
     }

disk/src/binned/query.rs

@@ -54,7 +54,7 @@ impl PreBinnedQuery {
         let disk_stats_every = disk_stats_every
             .parse()
             .map_err(|e| Error::with_msg(format!("can not parse diskStatsEveryKb {:?}", e)))?;
-        let ret = PreBinnedQuery {
+        let ret = Self {
             patch: PreBinnedPatchCoord::new(bin_t_len, patch_t_len, patch_ix),
             agg_kind: params
                 .get("aggKind")
@@ -177,8 +177,8 @@ pub struct BinnedQuery {
 }
 
 impl BinnedQuery {
-    pub fn new(channel: Channel, range: NanoRange, bin_count: u32, agg_kind: AggKind) -> BinnedQuery {
-        BinnedQuery {
+    pub fn new(channel: Channel, range: NanoRange, bin_count: u32, agg_kind: AggKind) -> Self {
+        Self {
             channel,
             range,
             bin_count,
@@ -199,7 +199,7 @@ impl BinnedQuery {
         let disk_stats_every = disk_stats_every
             .parse()
             .map_err(|e| Error::with_msg(format!("can not parse diskStatsEveryKb {:?}", e)))?;
-        let ret = BinnedQuery {
+        let ret = Self {
             range: NanoRange {
                 beg: beg_date.parse::<DateTime<Utc>>()?.to_nanos(),
                 end: end_date.parse::<DateTime<Utc>>()?.to_nanos(),
@@ -320,3 +320,82 @@ fn channel_from_params(params: &BTreeMap<String, String>) -> Result<Channel, Err
     };
     Ok(ret)
 }
+
+// TODO move this query type out of this `binned` mod
+#[derive(Clone, Debug)]
+pub struct PlainEventsQuery {
+    channel: Channel,
+    range: NanoRange,
+    report_error: bool,
+    timeout: Duration,
+}
+
+impl PlainEventsQuery {
+    pub fn new(channel: Channel, range: NanoRange) -> Self {
+        Self {
+            channel,
+            range,
+            report_error: false,
+            timeout: Duration::from_millis(2000),
+        }
+    }
+
+    pub fn from_request(req: &http::request::Parts) -> Result<Self, Error> {
+        let params = netpod::query_params(req.uri.query());
+        let beg_date = params.get("begDate").ok_or(Error::with_msg("missing begDate"))?;
+        let end_date = params.get("endDate").ok_or(Error::with_msg("missing endDate"))?;
+        let ret = Self {
+            range: NanoRange {
+                beg: beg_date.parse::<DateTime<Utc>>()?.to_nanos(),
+                end: end_date.parse::<DateTime<Utc>>()?.to_nanos(),
+            },
+            channel: channel_from_params(&params)?,
+            report_error: params
+                .get("reportError")
+                .map_or("false", |k| k)
+                .parse()
+                .map_err(|e| Error::with_msg(format!("can not parse reportError {:?}", e)))?,
+            timeout: params
+                .get("timeout")
+                .map_or("2000", |k| k)
+                .parse::<u64>()
+                .map(|k| Duration::from_millis(k))
+                .map_err(|e| Error::with_msg(format!("can not parse timeout {:?}", e)))?,
+        };
+        Ok(ret)
+    }
+
+    pub fn range(&self) -> &NanoRange {
+        &self.range
+    }
+
+    pub fn channel(&self) -> &Channel {
+        &self.channel
+    }
+
+    pub fn report_error(&self) -> bool {
+        self.report_error
+    }
+
+    pub fn timeout(&self) -> Duration {
+        self.timeout
+    }
+
+    pub fn set_timeout(&mut self, k: Duration) {
+        self.timeout = k;
+    }
+
+    pub fn url(&self, host: &HostPort) -> String {
+        let date_fmt = "%Y-%m-%dT%H:%M:%S.%3fZ";
+        format!(
+            "http://{}:{}/api/4/plain_events?channelBackend={}&channelName={}&begDate={}&endDate={}&timeout={}",
+            host.host,
+            host.port,
+            self.channel.backend,
+            self.channel.name,
+            Utc.timestamp_nanos(self.range.beg as i64).format(date_fmt),
+            Utc.timestamp_nanos(self.range.end as i64).format(date_fmt),
+            self.timeout.as_millis(),
+        )
+    }
+}