#[derive(Debug, Deserialize)]
pub struct LocationsResponse {
locations: Option<Vec<String>>,
#[serde(rename="errorString")]
error_string: Option<String>,
}
impl fmt::Display for LocationsResponse {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut out = String::new();
match self.locations {
Some(ref l) => {
for loc in l.iter() {
out.push_str(loc);
out.push_str("\n");
}
out = String::from(out.trim_right_matches("\n"));
},
None => { out.push_str("LOCATIONS: No locations found!"); }
}
::push_opt(&mut out, "Error: ", &self.error_string);
write!(f, "{}", out)
}
}
#[derive(Debug, Deserialize)]
pub struct DTError {
title: Option<String>,
#[serde(rename="type")]
ccu_type: Option<String>,
status: Option<usize>,
detail: Option<String>,
instance: Option<String>,
#[serde(rename="authzRealm")]
authz_realm: Option<String>,
method: Option<String>,
#[serde(rename="serverIp")]
server_ip: Option<String>,
#[serde(rename="clientIp")]
client_ip: Option<String>,
#[serde(rename="requestId")]
request_id: Option<String>,
#[serde(rename="requestTime")]
request_time: Option<String>,
}
impl fmt::Display for DTError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut out = String::new();
::push_opt(&mut out, "Title: ", &self.title);
::push_opt(&mut out, "Type: ", &self.ccu_type);
::push_opt(&mut out, "Status: ", &self.status);
::push_opt(&mut out, "Detail: ", &self.detail);
if out.is_empty() {
out.push_str("DTError: Unknown result!");
} else {
out = String::from(out.trim_right_matches("\n"));
}
write!(f, "{}", out)
}
}
#[derive(Debug, Deserialize)]
pub struct DigRecordData {
domain: Option<String>,
ttl: Option<usize>,
#[serde(rename="recordClass")]
record_class: Option<String>,
#[serde(rename="recordType")]
record_type: Option<String>,
#[serde(rename="preferenceValues")]
preference_values: Option<String>,
value: Option<String>,
}
impl fmt::Display for DigRecordData {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
" {: <40}{: <8}{: <8}{: <8}{: <8}{: <8}",
::to_str(&self.domain),
::to_str(&self.ttl),
::to_str(&self.record_class),
::to_str(&self.record_type),
::to_str(&self.preference_values),
::to_str(&self.value)
)
}
}
#[derive(Debug, Deserialize)]
pub struct DigData {
hostname: Option<String>,
#[serde(rename="queryType")]
query_type: Option<String>,
#[serde(rename="answerSection")]
answer_section: Option<Vec<DigRecordData>>,
#[serde(rename="authoritySection")]
authority_section: Option<Vec<DigRecordData>>,
result: Option<String>,
#[serde(rename="errorString")]
error_string: Option<String>,
}
impl fmt::Display for DigData {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut out = String::new();
::push_opt(&mut out, "Hostname: ", &self.hostname);
::push_opt(&mut out, "Query Type: ", &self.query_type);
match self.answer_section {
Some(ref asec) => {
out.push_str("Answer Section:\n");
for r in asec.iter() {
out.push_str(&format!("{}\n", r)[..]);
}
},
None => {},
}
match self.authority_section {
Some(ref asec) => {
out.push_str("Authority Section:\n");
for r in asec.iter() {
out.push_str(&format!("{}\n", r)[..]);
}
},
None => {},
}
::push_opt(&mut out, "Result: ", &self.result);
::push_opt(&mut out, "Error: ", &self.error_string);
if out.is_empty() {
out.push_str("DIG: Unknown result!");
} else {
out = String::from(out.trim_right_matches("\n"));
}
write!(f, "{}", out)
}
}
#[derive(Debug, Deserialize)]
pub struct DigResponse {
dig: DigData,
}
impl fmt::Display for DigResponse {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.dig)
}
}
#[derive(Debug, Deserialize)]
pub struct MtrHop {
num: Option<String>,
host: Option<String>,
loss: Option<String>,
sent: Option<String>,
last: Option<String>,
avg: Option<String>,
best: Option<String>,
worst: Option<String>,
#[serde(rename="stDev")]
st_dev: Option<String>,
}
impl fmt::Display for MtrHop {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
" {: <7}{: <27} loss: {: >5.5} sent: {: >4.4} last: {: >6.6} \
avg: {: >6.6} best: {: >6.6} worst: {: >6.6} stdev: {: >6.6}",
::to_str(&self.num),
::to_str(&self.host),
::to_str(&self.loss),
::to_str(&self.sent),
::to_str(&self.last),
::to_str(&self.avg),
::to_str(&self.best),
::to_str(&self.worst),
::to_str(&self.st_dev)
)
}
}
#[derive(Debug, Deserialize)]
pub struct MtrData {
source: Option<String>,
destination: Option<String>,
host: Option<String>,
#[serde(rename="packetLoss")]
packet_loss: Option<String>,
#[serde(rename="avgLatency")]
avg_latency: Option<String>,
analysis: Option<String>,
#[serde(rename="errorString")]
error_string: Option<String>,
hops: Option<Vec<MtrHop>>
}
impl fmt::Display for MtrData {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut out = String::new();
::push_opt(&mut out, "Source: ", &self.source);
::push_opt(&mut out, "Destination: ", &self.destination);
::push_opt(&mut out, "Host: ", &self.host);
::push_opt(&mut out, "Packet Loss: ", &self.packet_loss);
::push_opt(&mut out, "Avg Latency: ", &self.avg_latency);
::push_opt(&mut out, "Analysis: ", &self.analysis);
out.push_str("Hops:\n");
match self.hops {
Some(ref hops) => {
for hop in hops.iter() {
out.push_str(&format!("{}\n", hop)[..]);
}
},
None => {}
}
::push_opt(&mut out, "Error: ", &self.error_string);
if out.is_empty() {
out.push_str("MTR: No result!");
} else {
out = String::from(out.trim_right_matches("\n"));
}
write!(f, "{}", out)
}
}
#[derive(Debug, Deserialize)]
pub struct MtrResponse {
mtr: MtrData,
}
impl fmt::Display for MtrResponse {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.mtr)
}
}
#[derive(Debug, Deserialize)]
pub struct IPGeoLocationData {
#[serde(rename="clientIp")]
client_ip: Option<String>,
#[serde(rename="countryCode")]
country_code: Option<String>,
#[serde(rename="regionCode")]
region_code: Option<String>,
city: Option<String>,
dma: Option<String>,
msa: Option<String>,
pmsa: Option<String>,
#[serde(rename="areaCode")]
area_code: Option<String>,
latitude: Option<String>,
longitude: Option<String>,
county: Option<String>,
continent: Option<String>,
fips: Option<String>,
#[serde(rename="timeZone")]
time_zone: Option<String>,
network: Option<String>,
#[serde(rename="networkType")]
network_type: Option<String>,
#[serde(rename="zipCode")]
zip_code: Option<String>,
throughput: Option<String>,
#[serde(rename="asNum")]
asnum: Option<String>,
#[serde(rename="errorString")]
error_string: Option<String>,
}
impl fmt::Display for IPGeoLocationData {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut out = String::new();
::push_opt(&mut out, "Client IP: ", &self.client_ip);
::push_opt(&mut out, "Country Code: ", &self.country_code);
::push_opt(&mut out, "Region Code: ", &self.region_code);
::push_opt(&mut out, "City: ", &self.city);
::push_opt(&mut out, "DMA: ", &self.dma);
::push_opt(&mut out, "MSA: ", &self.msa);
::push_opt(&mut out, "PMSA: ", &self.pmsa);
::push_opt(&mut out, "Area Code: ", &self.area_code);
::push_opt(&mut out, "Latitude: ", &self.latitude);
::push_opt(&mut out, "Longitude: ", &self.longitude);
::push_opt(&mut out, "County: ", &self.county);
::push_opt(&mut out, "Continent: ", &self.continent);
::push_opt(&mut out, "FIPS: ", &self.fips);
::push_opt(&mut out, "Time Zone: ", &self.time_zone);
::push_opt(&mut out, "Network: ", &self.network);
::push_opt(&mut out, "Network Type: ", &self.network_type);
::push_opt(&mut out, "Zip Code: ", &self.zip_code);
::push_opt(&mut out, "Throughput: ", &self.throughput);
::push_opt(&mut out, "ASNum: ", &self.asnum);
::push_opt(&mut out, "Error: ", &self.error_string);
if out.is_empty() {
out.push_str("GEO: No result!");
} else {
out = String::from(out.trim_right_matches("\n"));
}
write!(f, "{}", out)
}
}
#[derive(Debug, Deserialize)]
pub struct IPGeoLocationResponse {
#[serde(rename="ipGeoLocation")]
geo: IPGeoLocationData
}
impl fmt::Display for IPGeoLocationResponse {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.geo)
}
}
#[derive(Debug, Deserialize)]
pub struct ArlData {
#[serde(rename="typeCode")]
type_code: Option<String>,
#[serde(rename="originServer")]
origin_server: Option<String>,
#[serde(rename="cpCode")]
cp_code: Option<String>,
#[serde(rename="serialNumber")]
serial_number: Option<String>,
ttl: Option<String>,
pragma: Option<String>,
#[serde(rename="cacheControl")]
cache_control: Option<String>,
#[serde(rename="errorString")]
error_string: Option<String>,
}
impl fmt::Display for ArlData {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut out = String::new();
::push_opt(&mut out, "Type Code: ", &self.type_code);
::push_opt(&mut out, "Origin Server: ", &self.origin_server);
::push_opt(&mut out, "CPCode: ", &self.cp_code);
::push_opt(&mut out, "Serial Number: ", &self.serial_number);
::push_opt(&mut out, "TTL: ", &self.ttl);
::push_opt(&mut out, "Pragma: ", &self.pragma);
::push_opt(&mut out, "Cache Control: ", &self.cache_control);
::push_opt(&mut out, "Error: ", &self.error_string);
if out.is_empty() {
out.push_str("TRANSLATE: No result!");
} else {
out = String::from(out.trim_right_matches("\n"));
}
write!(f, "{}", out)
}
}
#[derive(Debug, Deserialize)]
pub struct ArlResponse {
arl: ArlData
}
impl fmt::Display for ArlResponse {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.arl)
}
}
#[derive(Debug, Deserialize)]
pub struct LogLine {
#[serde(rename="logLine")]
log_line: Option<String>,
fields: Option<String>,
}
impl fmt::Display for LogLine {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}: {}", ::to_str(&self.log_line), ::to_str(&self.fields))
}
}
#[derive(Debug, Deserialize)]
pub struct ErrorData {
url: Option<String>,
#[serde(rename="httpResponseCode")]
http_response_code: Option<usize>,
#[serde(rename="dateTime")]
date_time: Option<String>,
#[serde(rename="epochTime")]
epoch_time: Option<String>,
#[serde(rename="clientIP")]
client_ip: Option<String>,
#[serde(rename="serverIP")]
server_ip: Option<String>,
#[serde(rename="originHostname")]
origin_hostname: Option<String>,
#[serde(rename="originIP")]
origin_ip: Option<String>,
#[serde(rename="userAgent")]
user_agent: Option<String>,
#[serde(rename="requestMethod")]
request_method: Option<String>,
#[serde(rename="reasonForFailure")]
reason_for_failure: Option<String>,
logs: Option<Vec<LogLine>>,
#[serde(rename="errorString")]
error_string: Option<String>,
}
impl fmt::Display for ErrorData {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut out = String::new();
::push_opt(&mut out, "URL: ", &self.url);
::push_opt(&mut out, "HTTP Response Code: ", &self.http_response_code);
::push_opt(&mut out, "Date/Time: ", &self.date_time);
::push_opt(&mut out, "Epoch Time: ", &self.epoch_time);
::push_opt(&mut out, "Client IP: ", &self.client_ip);
::push_opt(&mut out, "Server IP: ", &self.server_ip);
::push_opt(&mut out, "Origin Hostname: ", &self.origin_hostname);
::push_opt(&mut out, "Origin IP: ", &self.origin_ip);
::push_opt(&mut out, "User Agent: ", &self.user_agent);
::push_opt(&mut out, "Request Method: ", &self.request_method);
::push_opt(&mut out, "Reason For Failure: ", &self.reason_for_failure);
out.push_str("Logs:\n");
match self.logs {
Some(ref logs) => {
for log in logs.iter() {
out.push_str(&format!("{}\n", log)[..]);
}
},
None => {}
}
::push_opt(&mut out, "Error: ", &self.error_string);
if out.is_empty() {
out.push_str("ERROR TRANSLATE: No result!");
} else {
out = String::from(out.trim_right_matches("\n"));
}
write!(f, "{}", out)
}
}
#[derive(Debug, Deserialize)]
pub struct ErrorTranslateResponse {
#[serde(rename="errorTranslator")]
error_translator: ErrorData
}
impl fmt::Display for ErrorTranslateResponse {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.error_translator)
}
}
#[derive(Debug, Deserialize)]
pub struct VerifyIPCDNResponse {
#[serde(rename="isCdnIP")]
is_cdn_ip: Option<String>,
#[serde(rename="errorString")]
error_string: Option<String>,
ip: Option<String>,
}
impl fmt::Display for VerifyIPCDNResponse {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut out = String::new();
::push_opt(&mut out, "Is CDN IP: ", &self.is_cdn_ip);
::push_opt(&mut out, "IP: ", &self.ip);
::push_opt(&mut out, "Error: ", &self.error_string);
if out.is_empty() {
out.push_str("VERIFY CDN IP: No result!");
} else {
out = String::from(out.trim_right_matches("\n"));
}
write!(f, "{}", out)
}
}