Adds unzip module

Cargo.toml

@@ -35,6 +35,7 @@ lazy_static = { version = "1.4", optional = true }
 once_cell = { version = "1.4", optional = true }
 mysql = { version = "20.0", optional = true }
 dashmap = { version = "3.11", optional = true }
+zip = { version = "0.5.8", optional = true }
 
 
 [features]
@@ -49,3 +50,4 @@ git = ["git2", "chrono"]
 http = ["reqwest", "serde", "serde_json", "once_cell", "jobs"]
 sql = ["mysql", "serde", "serde_json", "once_cell", "dashmap", "jobs"]
 jobs = ["flume"]
+unzip = ["zip", "jobs"]

dmsrc/unzip.dm

@@ -0,0 +1,2 @@
+#define rustg_unzip_download_async(url, unzip_directory) call(RUST_G, "unzip_download_async")(url, unzip_directory)
+#define rustg_unzip_check(job_id) call(RUST_G, "unzip_check")("[job_id]")

src/error.rs

@@ -9,6 +9,9 @@ use thiserror::Error;
 #[cfg(feature = "png")]
 use png::{DecodingError, EncodingError};
 
+#[cfg(feature = "unzip")]
+use zip::result::ZipError;
+
 pub type Result<T> = result::Result<T, Error>;
 
 #[derive(Error, Debug)]
@@ -42,6 +45,9 @@ pub enum Error {
     #[cfg(feature = "http")]
     #[error(transparent)]
     SerializationError(#[from] serde_json::Error),
+    #[cfg(feature = "unzip")]
+    #[error(transparent)]
+    UnzipError(#[from] ZipError)
 }
 
 impl From<Utf8Error> for Error {

src/http.rs

@@ -76,7 +76,7 @@ fn setup_http_client() -> reqwest::blocking::Client {
     Client::builder().default_headers(headers).build().unwrap()
 }
 
-static HTTP_CLIENT: Lazy<reqwest::blocking::Client> = Lazy::new(setup_http_client);
+pub static HTTP_CLIENT: Lazy<reqwest::blocking::Client> = Lazy::new(setup_http_client);
 
 // ----------------------------------------------------------------------------
 // Request construction and execution

src/lib.rs

@@ -26,6 +26,8 @@ pub mod noise_gen;
 pub mod sql;
 #[cfg(feature = "url")]
 pub mod url;
+#[cfg(feature = "unzip")]
+pub mod unzip;
 
 #[cfg(not(target_pointer_width = "32"))]
 compile_error!("rust-g must be compiled for a 32-bit target");

src/unzip.rs

@@ -0,0 +1,68 @@
+use crate::{error::Result, jobs, http::HTTP_CLIENT};
+use reqwest::blocking::RequestBuilder;
+use std::fs;
+use std::io::Write;
+use std::path::Path;
+use zip::ZipArchive;
+
+struct UnzipPrep {
+    req: RequestBuilder,
+    unzip_directory: String,
+}
+
+fn construct_unzip(
+    url: &str,
+    unzip_directory: &str
+) -> UnzipPrep {
+
+    let req = HTTP_CLIENT.get(url);
+    let dir_copy = unzip_directory.to_string();
+
+    UnzipPrep {
+        req,
+        unzip_directory: dir_copy,
+    }
+}
+
+byond_fn! { unzip_download_async(url, unzip_directory) {
+    let unzip = construct_unzip(&url, &unzip_directory);
+    Some(jobs::start(move ||
+        do_unzip_download(unzip).unwrap_or_else(|e| e.to_string())
+    ))
+} }
+
+fn do_unzip_download(prep: UnzipPrep) -> Result<String> {
+    let unzip_path = Path::new(&prep.unzip_directory);
+    let response = prep.req.send()?;
+
+    let content = response.bytes()?;
+
+    let reader = std::io::Cursor::new(content);
+    let mut archive = ZipArchive::new(reader)?;
+
+    for i in 0..archive.len()
+    {
+        let mut entry = archive.by_index(i)?;
+
+        let file_path = unzip_path.join(entry.name());
+
+        if let Some(parent) = file_path.parent() {
+            fs::create_dir_all(parent)?
+        }
+
+        let file = fs::OpenOptions::new()
+            .write(true)
+            .create(true)
+            .open(&file_path)?;
+
+        let mut writer = std::io::BufWriter::new(file);
+        std::io::copy(&mut entry, &mut writer)?;
+        writer.flush()?;
+    }
+
+    Ok("true".to_string())
+}
+
+byond_fn! { unzip_check(id) {
+    Some(jobs::check(id))
+} }