Browse Source

Add multithreading

master
Teascade 2 years ago
parent
commit
f45a39b960
  1. 4
      Cargo.lock
  2. 4
      config.toml
  3. 48
      src/api.rs
  4. 2
      src/config.rs
  5. 8
      src/errors.rs
  6. 36
      src/main.rs

4
Cargo.lock

@ -126,9 +126,9 @@ dependencies = [
[[package]]
name = "minreq"
version = "2.2.0"
version = "2.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ab229c252995e9d56cc66857f3ab2c41e3138b1a6c92089f013698388e64d6bd"
checksum = "2466d0a7e6bfcd54f69e4a17d4a4318985aaaf7fe3df4cd3b6f11ff551129ca3"
dependencies = [
"lazy_static",
"rustls",

4
config.toml

@ -1,7 +1,7 @@
api_key = ""
api_key = "E3GrOiQAnY61BP623XXzt9Fo87A1IQrS1FFzD57P"
tags_url = "https://platform.yepzon.com/tags"
states_url = "https://platform.yepzon.com/tags/{tag}/states"
locations_url = "https://platform.yepzon.com/tags/{tag}/locations/{state}"
timestamp_format = "%Y-%m-%dT%H:%M:%S%.fZ"
between_format = "%d.%m.%Y %H:%M:%S"
throttle = 110
throttle = 10

48
src/api.rs

@ -2,9 +2,13 @@ use super::Config;
use super::GenericError;
use chrono::format::ParseError;
use chrono::NaiveDateTime;
use minreq::{Error, Response};
use minreq::Response;
use serde::Deserialize;
use std::sync::mpsc;
use std::sync::mpsc::Receiver;
use std::thread;
use std::thread::sleep;
use std::thread::Thread;
use std::time::{Duration, Instant};
pub trait Timestamped {
@ -67,6 +71,8 @@ impl Timestamped for LocationModel {
pub struct API {
config: Config,
pub last_response_ping: u32,
location_req_que: Vec<String>,
}
impl API {
@ -74,6 +80,8 @@ impl API {
API {
last_response_ping: config.throttle,
config: config,
location_req_que: Vec::new(),
}
}
@ -93,15 +101,39 @@ impl API {
Ok(response.json()?)
}
pub fn get_locations(
&mut self,
tag_id: &String,
state_id: &String,
) -> Result<Vec<LocationModel>, GenericError> {
pub fn queue_location(&mut self, tag_id: &String, state_id: &String) {
let url = str::replace(&self.config.locations_url, "{tag}", &tag_id);
let url = str::replace(&url, "{state}", &state_id);
let response = self.request(url)?;
Ok(response.json()?)
self.location_req_que.push(url);
//let response = self.request(url)?;
//Ok(response.json()?)
}
pub fn begin_location_fetch(&mut self) -> Receiver<Result<String, GenericError>> {
let (sender, receiver) = mpsc::channel();
let locations = self.location_req_que.clone();
let config = self.config.clone();
thread::spawn(move || {
for location in locations {
let sender = sender.clone();
let config = config.clone();
thread::spawn(move || {
println!("Send req!");
let response = minreq::get(location)
.with_header("content-type", "application/json")
.with_header("x-api-key", &config.api_key)
.send()
.map_err(GenericError::from)
.and_then(|r| {
String::from_utf8(r.into_bytes()).map_err(GenericError::from)
});
sender.send(response).ok();
});
thread::sleep_ms(100);
}
});
self.location_req_que.clear();
receiver
}
pub fn get_between<T: Timestamped>(

2
src/config.rs

@ -26,7 +26,7 @@ impl Default for Config {
timestamp_format: "%Y-%m-%dT%H:%M:%S%.fZ".to_owned(),
between_format: "%d.%m.%Y %H:%M:%S".to_owned(),
throttle: 110,
throttle: 10,
}
}
}

8
src/errors.rs

@ -8,6 +8,8 @@ pub enum GenericError {
MinreqError(minreq::Error),
ChronoParseError(chrono::ParseError),
IOError(io::Error),
FromUTF8Error(std::string::FromUtf8Error),
OutOfLocations,
}
impl From<toml::de::Error> for GenericError {
@ -39,3 +41,9 @@ impl From<io::Error> for GenericError {
GenericError::IOError(error)
}
}
impl From<std::string::FromUtf8Error> for GenericError {
fn from(error: std::string::FromUtf8Error) -> Self {
GenericError::FromUTF8Error(error)
}
}

36
src/main.rs

@ -10,6 +10,7 @@ use config::Config;
use errors::GenericError;
use std::fs::File;
use std::io::prelude::*;
use std::sync::mpsc::TryRecvError;
fn main() {
let env: EnvOpt = argh::from_env();
@ -28,7 +29,11 @@ fn from_env(env: EnvOpt) -> Result<(), GenericError> {
let config: Config = toml::from_str(&string)?;
run(&config, None, None)?;
run(
&config,
Some("1.1.2019 00:00:00".to_owned()),
Some("1.5.2020 00:00:00".to_owned()),
)?;
Ok(())
}
Subcommand::Init(opt) => {
@ -52,16 +57,31 @@ fn run(config: &Config, from: Option<String>, to: Option<String>) -> Result<(),
let state_list = api.get_states(&first_tag)?;
let states = API::get_between(state_list.clone(), from, to, true, &config);
let len = states.len();
let mut locations = Vec::new();
for (idx, (_, state)) in states.iter().enumerate() {
println!("Expected {}s left", exp_time(&api, (len - idx) as u32));
let mut location_list = api.get_locations(&first_tag, state.id.as_ref().unwrap())?;
locations.append(&mut location_list);
//let mut locations = Vec::new();
for (_, state) in states.iter() {
api.queue_location(&first_tag, state.id.as_ref().unwrap());
}
let receiver = api.begin_location_fetch();
loop {
match receiver.try_recv() {
Ok(res) => match res {
Ok(loc) => {
let mut loc = loc;
println!("Received! {}", loc);
//locations.append(&mut loc);
}
Err(e) => eprintln!("{:?}", e),
},
Err(e) => {
if let TryRecvError::Disconnected = e {
break;
}
}
}
}
dbg!(API::get_between(locations, from, to, false, &config));
//dbg!(API::get_between(locations, from, to, false, &config));
Ok(())
}

Loading…
Cancel
Save