Factored into separate crate

src/api4.rs

@@ -0,0 +1,176 @@
+pub mod binned;
+pub mod events;
+
+use chrono::DateTime;
+use chrono::TimeZone;
+use chrono::Utc;
+use netpod::get_url_query_pairs;
+use netpod::range::evrange::SeriesRange;
+use netpod::ttl::RetentionTime;
+use netpod::AppendToUrl;
+use netpod::FromUrl;
+use netpod::HasBackend;
+use netpod::HasTimeout;
+use netpod::ToNanos;
+use netpod::TsNano;
+use netpod::DATETIME_FMT_6MS;
+use serde::Deserialize;
+use serde::Serialize;
+use std::collections::BTreeMap;
+use std::time::Duration;
+use url::Url;
+
+#[derive(Debug, thiserror::Error)]
+#[cstm(name = "Query")]
+pub enum Error {
+    MissingTimerange,
+    ChronoParse(#[from] chrono::ParseError),
+    HumantimeDurationParse(#[from] humantime::DurationError),
+    MissingBackend,
+    MissingRetentionTime,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AccountingIngestedBytesQuery {
+    backend: String,
+    range: SeriesRange,
+}
+
+impl AccountingIngestedBytesQuery {
+    pub fn range(&self) -> &SeriesRange {
+        &self.range
+    }
+}
+
+impl HasBackend for AccountingIngestedBytesQuery {
+    fn backend(&self) -> &str {
+        &self.backend
+    }
+}
+
+impl HasTimeout for AccountingIngestedBytesQuery {
+    fn timeout(&self) -> Option<Duration> {
+        None
+    }
+}
+
+impl FromUrl for AccountingIngestedBytesQuery {
+    type Error = netpod::NetpodError;
+
+    fn from_url(url: &Url) -> Result<Self, Self::Error> {
+        let pairs = get_url_query_pairs(url);
+        Self::from_pairs(&pairs)
+    }
+
+    fn from_pairs(pairs: &BTreeMap<String, String>) -> Result<Self, Self::Error> {
+        let ret = Self {
+            backend: pairs
+                .get("backend")
+                .ok_or_else(|| netpod::NetpodError::MissingBackend)?
+                .to_string(),
+            range: SeriesRange::from_pairs(pairs)?,
+        };
+        Ok(ret)
+    }
+}
+
+impl AppendToUrl for AccountingIngestedBytesQuery {
+    fn append_to_url(&self, url: &mut Url) {
+        {
+            let mut g = url.query_pairs_mut();
+            g.append_pair("backend", &self.backend);
+        }
+        self.range.append_to_url(url);
+    }
+}
+
+//
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AccountingToplistQuery {
+    rt: RetentionTime,
+    backend: String,
+    ts: TsNano,
+    limit: u32,
+    sort: Option<String>,
+}
+
+impl AccountingToplistQuery {
+    pub fn rt(&self) -> RetentionTime {
+        self.rt.clone()
+    }
+
+    pub fn ts(&self) -> TsNano {
+        self.ts.clone()
+    }
+
+    pub fn limit(&self) -> u32 {
+        self.limit
+    }
+
+    pub fn sort(&self) -> Option<&str> {
+        self.sort.as_ref().map(|x| x.as_str())
+    }
+}
+
+impl HasBackend for AccountingToplistQuery {
+    fn backend(&self) -> &str {
+        &self.backend
+    }
+}
+
+impl HasTimeout for AccountingToplistQuery {
+    fn timeout(&self) -> Option<Duration> {
+        None
+    }
+}
+
+impl FromUrl for AccountingToplistQuery {
+    type Error = Error;
+
+    fn from_url(url: &Url) -> Result<Self, Self::Error> {
+        let pairs = get_url_query_pairs(url);
+        Self::from_pairs(&pairs)
+    }
+
+    fn from_pairs(pairs: &BTreeMap<String, String>) -> Result<Self, Self::Error> {
+        let fn1 = |pairs: &BTreeMap<String, String>| {
+            let v = pairs.get("tsDate").ok_or(Self::Error::MissingTimerange)?;
+            let mut w = v.parse::<DateTime<Utc>>();
+            if w.is_err() && v.ends_with("ago") {
+                let d = humantime::parse_duration(&v[..v.len() - 3])?;
+                w = Ok(Utc::now() - d);
+            }
+            let w = w?;
+            Ok::<_, Self::Error>(TsNano::from_ns(w.to_nanos()))
+        };
+        let ret = Self {
+            rt: pairs
+                .get("retentionTime")
+                .ok_or_else(|| Self::Error::MissingRetentionTime)
+                .and_then(|x| x.parse().map_err(|_| Self::Error::MissingRetentionTime))?,
+            backend: pairs
+                .get("backend")
+                .ok_or_else(|| Self::Error::MissingBackend)?
+                .to_string(),
+            ts: fn1(pairs)?,
+            limit: pairs.get("limit").map_or(None, |x| x.parse().ok()).unwrap_or(20),
+            sort: pairs.get("sort").map(ToString::to_string),
+        };
+        Ok(ret)
+    }
+}
+
+impl AppendToUrl for AccountingToplistQuery {
+    fn append_to_url(&self, url: &mut Url) {
+        let mut g = url.query_pairs_mut();
+        g.append_pair("backend", &self.backend);
+        g.append_pair(
+            "ts",
+            &Utc.timestamp_nanos(self.ts.ns() as i64)
+                .format(DATETIME_FMT_6MS)
+                .to_string(),
+        );
+        g.append_pair("limit", &self.limit.to_string());
+    }
+}