backdownload

src/main.rs

@@ -4,6 +4,7 @@ use reqwest::{Client, Response};
 use serde::Deserialize;
 use serde_json::Value;
 use sqlx::postgres::PgPool;
+use std::env::args;
 use std::io::Cursor;
 use std::path::{Path, PathBuf};
 use std::time::Duration;
@@ -16,6 +17,20 @@ async fn main() -> Result<(), MainError> {
     let api_host = dotenv::var("API_HOST").unwrap_or_else(|_| "https://logs.tf".to_string());
     let log_target = PathBuf::from(dotenv::var("LOG_TARGET")?);
 
+    let args = args();
+
+    if args.len() > 1 {
+        let mut args = args.skip(1);
+        let from: i32 = args.next().unwrap().parse()?;
+        let to: i32 = args.next().unwrap().parse()?;
+        let client = reqwest::Client::new();
+        for id in from..=to {
+            println!("downloading {}", id);
+
+            download_log(&api_host, &log_target, &client, id).await?;
+            sleep(Duration::from_millis(200)).await;
+        }
+    } else {
         loop {
             if let Err(e) = archive(&database_url, &api_host, &log_target).await {
                 eprintln!("{:?}", e);
@@ -24,6 +39,8 @@ async fn main() -> Result<(), MainError> {
             sleep(Duration::from_secs(60)).await;
         }
     }
+    Ok(())
+}
 
 async fn get_last_demo(client: &Client, api_host: &str) -> Result<i32, MainError> {
     let response: Response = client
@@ -81,16 +98,34 @@ async fn archive(database_url: &str, api_host: &str, log_target: &Path) -> Resul
         .execute(&pool)
         .await?;
 
+        download_log(api_host, log_target, &client, last_archived).await?;
+    }
+
+    Ok(())
+}
+
+async fn download_log(
+    api_host: &str,
+    log_target: &Path,
+    client: &Client,
+    id: i32,
+) -> Result<(), MainError> {
     let log_zip = client
-            .get(&format!("{}/logs/log_{}.log.zip", api_host, last_archived))
+        .get(&format!("{}/logs/log_{}.log.zip", api_host, id))
         .send()
         .await?
         .bytes()
         .await?;
-        let mut archive = ZipArchive::new(Cursor::new(&log_zip))?;
+    let mut archive = match ZipArchive::new(Cursor::new(&log_zip)) {
-        archive.extract(log_target)?;
+        Ok(archive) => archive,
+        Err(e) => {
+            eprintln!("Error extracting log: {:#}", e);
+            return Ok(());
+        }
+    };
+    if let Err(e) = archive.extract(&log_target) {
+        eprintln!("Error extracting log: {:#}", e);
     }
-
     Ok(())
 }