Merge pull request #55 from bgpkit/feature/time-multiple-input

support querying multiple time strings

src/bin/monocle.rs

@@ -280,7 +280,7 @@ enum Commands {
  Time {
  /// Time stamp or time string to convert
  #[clap()]
- time: Option<String>,
+ time: Vec<String>,
 
  /// Simple output, only print the converted time
  #[clap(short, long)]

src/database.rs

@@ -89,7 +89,7 @@ impl MsgStore {
  ElemType::ANNOUNCE => "A",
  ElemType::WITHDRAW => "W",
  };
- let origin_string = elem.origin_asns.as_ref().map(|asns| asns.get(0).unwrap());
+ let origin_string = elem.origin_asns.as_ref().map(|asns| asns.first().unwrap());
  format!(
  "('{}','{}','{}','{}','{}', {},{},{},{},{},{},{},'{}',{},{})",
  elem.timestamp as u32,

src/lib.rs

@@ -4,7 +4,7 @@ mod datasets;
 
 use anyhow::{anyhow, Result};
 use bgpkit_parser::BgpkitParser;
-use chrono::{NaiveDateTime, TimeZone, Utc};
+use chrono::{DateTime, TimeZone, Utc};
 use chrono_humanize::HumanTime;
 use itertools::Itertools;
 use std::io::Read;
@@ -23,7 +23,7 @@ pub fn parser_with_filters(
  prefix: &Option<String>,
  include_super: &bool,
  include_sub: &bool,
- peer_ip: &Vec<IpAddr>,
+ peer_ip: &[IpAddr],
  peer_asn: &Option<u32>,
  elem_type: &Option<String>,
  start_ts: &Option<String>,
@@ -101,54 +101,61 @@ pub fn string_to_time(time_string: &str) -> Result<i64> {
  Ok(ts)
 }
 
-pub fn convert_time_string(time_string: &Option<String>) -> Result<String> {
- let unix = match time_string {
- None => Utc::now().to_rfc3339(),
- Some(ts) => {
+pub fn convert_time_string(time_vec: &[String]) -> Result<String> {
+ let time_strings = match time_vec.len() {
+ 0 => vec![Utc::now().to_rfc3339()],
+ _ => {
  // check if ts is a valid Unix timestamp
- match ts.parse::<f64>() {
- Ok(timestamp) => {
- let dt = Utc.timestamp_opt(timestamp as i64, 0).unwrap();
- dt.to_rfc3339()
- }
- Err(_) => {
- // not a time stamp, check if it is a valid RFC3339 string,
- // if so, return the unix timestamp as string; otherwise, return error
- match chrono::DateTime::parse_from_rfc3339(ts) {
- Ok(dt) => dt.timestamp().to_string(),
+ time_vec
+ .iter()
+ .map(|ts| {
+ match ts.parse::<f64>() {
+ Ok(timestamp) => {
+ let dt = Utc.timestamp_opt(timestamp as i64, 0).unwrap();
+ dt.to_rfc3339()
+ }
  Err(_) => {
- return Err(anyhow!(
- "Input time must be either Unix timestamp or time string compliant with RFC3339"
- ))
+ // not a time stamp, check if it is a valid RFC3339 string,
+ // if so, return the unix timestamp as string; otherwise, return error
+ match chrono::DateTime::parse_from_rfc3339(ts) {
+ Ok(dt) => dt.timestamp().to_string(),
+ Err(_) => "".to_string(),
+ }
  }
  }
- }
- }
+ })
+  .collect()
  }
  };
 
- Ok(unix)
+ Ok(time_strings.join("\n"))
 }
 
-pub fn time_to_table(time_string: &Option<String>) -> Result<String> {
+pub fn time_to_table(time_vec: &[String]) -> Result<String> {
  let now_ts = Utc::now().timestamp();
- let unix = match time_string {
- None => now_ts,
- Some(ts) => string_to_time(ts.as_str())?,
+ let ts_vec = match time_vec.is_empty() {
+ true => vec![now_ts],
+ false => time_vec
+ .iter()
+ .map(|ts| string_to_time(ts.as_str()).unwrap_or_default())
+ .collect(),
  };
 
- let ht = HumanTime::from(chrono::Local::now() - chrono::Duration::seconds(now_ts - unix));
- let human = ht.to_string();
-
- let rfc3339 = Utc
- .from_utc_datetime(&NaiveDateTime::from_timestamp_opt(unix, 0).unwrap())
- .to_rfc3339();
+ let bgptime_vec = ts_vec
+ .into_iter()
+ .map(|ts| {
+ let ht = HumanTime::from(chrono::Local::now() - chrono::Duration::seconds(now_ts - ts));
+ let human = ht.to_string();
+ let rfc3339 = Utc
+ .from_utc_datetime(&DateTime::from_timestamp(ts, 0).unwrap().naive_utc())
+ .to_rfc3339();
+ BgpTime {
+ unix: ts,
+ rfc3339,
+ human,
+ }
+ })
+ .collect::<Vec<BgpTime>>();
 
- Ok(Table::new(vec![BgpTime {
- unix,
- rfc3339,
- human,
- }])
- .with(Style::rounded())
- .to_string())
+ Ok(Table::new(bgptime_vec).with(Style::rounded()).to_string())
 }