Struct QueryParams 

pub struct QueryParams {
    pub ts_start: Option<String>,
    pub ts_end: Option<String>,
    pub collector_id: Option<String>,
    pub project: Option<String>,
    pub data_type: Option<String>,
    pub page: i64,
    pub page_size: i64,
    pub peers_ip: Option<IpAddr>,
    pub peers_asn: Option<u32>,
    pub peers_only_full_feed: bool,
}

QueryParams represents the query parameters to the backend API.

Example for constructing a QueryParams:

use bgpkit_broker::QueryParams;
let mut params = QueryParams::new();
params = params.ts_start("1633046400");
params = params.ts_end("1633132800");
params = params.collector_id("rrc00");
params = params.project("riperis");
params = params.data_type("rib");
params = params.page(2);
params = params.page_size(20);

The above example constructs a query that searches for BGP archive files that are:

• after 2021-10-01T00:00:00 UTC
• before 2021-10-02T00:00:00 UTC
• from collector rrc00
• from riperis collectors (already implied by collector=rrc00 though)
• rib table dump files
• second page
• each page contains 20 items

Fields

ts_start: Option<String>

start unix timestamp: files with time after or equals to ts_start will match

ts_end: Option<String>

end unix timestamp: files with time before or equals to ts_end will match

collector_id: Option<String>

collector identifier, e.g. rrc00 or route-views2

project: Option<String>

archive project name: riperis or routeviews

data_type: Option<String>

archive data type: rib or updates

page: i64

page number to seek to, starting from 1, default to 1

page_size: i64

number of items each page contains, default to 10, max to 100000

peers_ip: Option<IpAddr>

collector peer IP address (for listing peers info)

peers_asn: Option<u32>

collector peer ASN (for listing peers info)

peers_only_full_feed: bool

collector peer full feed status (for listing peers info)

Implementations

impl QueryParams

pub fn new() -> QueryParams

pub fn ts_start(self, ts_start: &str) -> Self

set starting timestamp for the search and returns a new QueryParams object.

use bgpkit_broker::QueryParams;
let mut params = QueryParams::new();
params = params.ts_start("1633046400");

pub fn ts_end(self, ts_end: &str) -> Self

set ending timestamp for the search and returns a new QueryParams object.

use bgpkit_broker::QueryParams;
let mut params = QueryParams::new();
params = params.ts_end("1633046400");

pub fn page(self, page: i64) -> Self

set page number for the each for pagination. the page number starts from 1.

use bgpkit_broker::QueryParams;
let mut params = QueryParams::new();
params = params.page(3);

pub fn page_size(self, page_size: i64) -> Self

set each page’s size (number of items per page).

use bgpkit_broker::QueryParams;
let mut params = QueryParams::new();
params = params.page_size(20);

pub fn data_type(self, data_type: &str) -> Self

set the type of data to search for:

• rib: table dump files
• updates: BGP updates files

Without specifying a data type, it defaults to search for all types.

use bgpkit_broker::QueryParams;
let mut params = QueryParams::new();
params = params.data_type("rib");

pub fn project(self, project: &str) -> Self

set searching for only data from specific project:

• routeviews: RouteViews
• riperis: RIPE RIS

use bgpkit_broker::QueryParams;
let mut params = QueryParams::new();
params = params.project("routeviews");

pub fn collector_id(self, collector_id: &str) -> Self

set searching for only data from specific collector, examples: rrc00, route-views2

use bgpkit_broker::QueryParams;
let mut params = QueryParams::new();
params = params.collector_id("rrc00");

Trait Implementations

impl Clone for QueryParams

fn clone(&self) -> QueryParams

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QueryParams

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for QueryParams

Default QueryParams values

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for QueryParams

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for QueryParams

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Serialize for QueryParams

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.