Update Rust crate zip to v2.2.1

Update Rust crate tokio to v1.41.1
Update Rust crate thiserror to v2
2024-11-22 00:15:43 +00:00 · 2024-11-08 00:12:56 +00:00 · 2024-11-07 00:13:38 +00:00 · 2024-11-04 00:12:50 +00:00 · 2024-11-01 00:32:36 +00:00 · 2024-10-29 00:26:32 +00:00
6 changed files with 1207 additions and 564 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,12 +1,12 @@
 [package]
 name = "grammalecte_client"
-version = "0.1.4"
+version = "0.1.5"
 edition = "2021"
 authors = ["Pierre Hubert <pierre.git@communiquons.org>"]
 description = "Grammalecte HTTP client"
 license = "MIT"
 repository = "https://gitea.communiquons.org/pierre/GrammalecteClient"
-keywords = ["grammalecte", "spell-check"]
+keywords = ["grammalecte", "spell-check", "spellcheck"]
 readme = "README.md"
 categories = ["text-processing"]

@ -14,17 +14,18 @@ categories = ["text-processing"]

 [dependencies]
 serde_json = "1.0.96"
-reqwest = { version = "0.11.18", features = ["json"] }
+reqwest = { version = "0.12.4", features = ["json"] }
 serde = { version = "1.0.163", features = ["derive"] }
 log = "0.4.17"
-zip = { version = "0.6.3", optional = true }
+zip = { version = "2.1.3", optional = true }
 mktemp = { version = "0.5.0", optional = true }
 rand = { version = "0.8.5", optional = true }
-port_scanner = {version = "0.1.5", optional = true}
+port_scanner = { version = "0.1.5", optional = true }
+thiserror = "1.0.61"

 [features]
 embedded-server = ["zip", "mktemp", "rand", "port_scanner"]

 [dev-dependencies]
-env_logger = "0.10.0"
+env_logger = "0.11.3"
 tokio = { version = "1.28.1", features = ["full"] }
--- a/renovate.json
+++ b/renovate.json
@ -0,0 +1,9 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "packageRules": [
+    {
+      "matchUpdateTypes": ["major", "minor", "patch"],
+      "automerge": true
+    }
+  ]
+}
--- a/src/GrammalecteDist.zip
+++ b/src/GrammalecteDist.zip
--- a/src/lib.rs
+++ b/src/lib.rs
@ -36,10 +36,11 @@
 //! println!("RESULT = {:#?}", res);
 //! ```

+use thiserror::Error;
+
 #[cfg(feature = "embedded-server")]
 use crate::server::EmbeddedServer;
 use std::collections::HashMap;
-use std::error::Error;

 #[cfg(feature = "embedded-server")]
 pub mod server;
@ -302,6 +303,28 @@ pub struct SuggestResult {
    pub suggestions: Vec<String>,
 }

+#[derive(Debug, Error)]
+pub enum Error {
+    #[cfg(feature = "embedded-server")]
+    #[error("Grammalecte-server failed to start")]
+    ServerStartFailed(#[from] server::Error),
+
+    #[error("Failed to Serialize Option in Json")]
+    OptionJsonSerialization(#[source] serde_json::Error),
+
+    #[error("Failed to send request `check with option`")]
+    RequestSendCheckWithOptions(#[source] reqwest::Error),
+
+    #[error("Failed to send request `suggest`")]
+    RequestSendSuggest(#[source] reqwest::Error),
+
+    #[error("Failed to Deserialize Check result")]
+    CheckResultDeserialize(#[source] reqwest::Error),
+
+    #[error("Failed to Deserialize Suggest result")]
+    SuggestDeserialize(#[source] reqwest::Error),
+}
+
 /// The Grammalecte client itself
 pub struct GrammalecteClient {
    base_url: String,
@ -335,7 +358,7 @@ impl GrammalecteClient {
    ///
    /// Python 3.7 or higher must is required at runtime
    #[cfg(feature = "embedded-server")]
-    pub fn start_server() -> Result<Self, Box<dyn Error>> {
+    pub fn start_server() -> Result<Self, Error> {
        let server = EmbeddedServer::start()?;
        Ok(Self {
            base_url: server.base_url(),
@ -344,7 +367,7 @@ impl GrammalecteClient {
    }

    /// Run spell check on text
-    pub async fn spell_check(&self, text: &str) -> Result<CheckResult, Box<dyn Error>> {
+    pub async fn spell_check(&self, text: &str) -> Result<CheckResult, Error> {
        self.spell_check_with_options(text, &HashMap::new()).await
    }

@ -353,7 +376,7 @@ impl GrammalecteClient {
        &self,
        text: &str,
        options: &HashMap<GramOpt, bool>,
-    ) -> Result<CheckResult, Box<dyn Error>> {
+    ) -> Result<CheckResult, Error> {
        let url = format!("{}/gc_text/fr", self.base_url);
        log::debug!("Will use URL {} for spell check", url);

@ -361,7 +384,7 @@ impl GrammalecteClient {
            .iter()
            .map(|t| (t.0.id(), t.1))
            .collect::<HashMap<_, _>>();
-        let options = serde_json::to_string(&options)?;
+        let options = serde_json::to_string(&options).map_err(Error::OptionJsonSerialization)?;

        let mut params = HashMap::new();
        params.insert("text", text);
@ -371,28 +394,32 @@ impl GrammalecteClient {
            .post(url)
            .form(&params)
            .send()
-            .await?
+            .await
+            .map_err(Error::RequestSendCheckWithOptions)?
            .json::<CheckResult>()
-            .await?;
+            .await
+            .map_err(Error::CheckResultDeserialize)?;

        Ok(result)
    }

    /// Ask for word suggestion
-    pub async fn suggest(&self, token: &str) -> Result<SuggestResult, Box<dyn Error>> {
+    pub async fn suggest(&self, token: &str) -> Result<SuggestResult, Error> {
        let url = format!("{}/suggest/fr", self.base_url);
        log::debug!("Will use URL {} for word suggestion", url);

        let mut params = HashMap::new();
        params.insert("token", token);

-        Ok(reqwest::Client::new()
+        reqwest::Client::new()
            .post(&url)
            .form(&params)
            .send()
-            .await?
+            .await
+            .map_err(Error::RequestSendSuggest)?
            .json()
-            .await?)
+            .await
+            .map_err(Error::SuggestDeserialize)
    }
 }

--- a/src/server.rs
+++ b/src/server.rs
@ -1,9 +1,48 @@
-use crate::server::utils::{get_free_port, wait_for_port};
+use crate::server::utils::{get_free_port, wait_for_server};
 use mktemp::Temp;
-use std::error::Error;
-use std::io::{Cursor, Read};
-use std::process::{Child, Stdio};
-use zip::ZipArchive;
+use std::io::{self, Cursor, Read};
+use std::process::{Child, ExitStatus, Stdio};
+use thiserror::Error;
+use zip::{result::ZipError, ZipArchive};
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("Grammalecte-server failed to launch process")]
+    StartServerProcess(#[source] io::Error),
+
+    #[error("Get an available port failed")]
+    GetFreePort(#[source] io::Error),
+
+    #[error("Server exit with `{status}`")]
+    ServerExitWithStatus { status: ExitStatus },
+
+    #[error("Server exit with `{status}` :\n{msg}")]
+    ServerExitWithError { status: ExitStatus, msg: String },
+
+    #[error("Error append during check grammalecte-server status")]
+    ServerCheckStatus(#[source] io::Error),
+
+    #[error("Port {port} did not open in time!")]
+    WaitPortOpen { port: u16 },
+
+    #[error("Create temporary directory failed")]
+    CreateTempDir(#[source] io::Error),
+
+    #[error("Zip archive loading failed")]
+    ZipArchiveLoading(#[source] ZipError),
+
+    #[error("Access file by index failed")]
+    ZipFileIndex(#[source] ZipError),
+
+    #[error("Create directory for files from zip")]
+    CreateDirectoryForZipFile(#[source] io::Error),
+
+    #[error("Read file from zip archive")]
+    ZipFileReadToEnd(#[source] io::Error),
+
+    #[error("Write file from archive on disk")]
+    WriteFile(#[source] io::Error),
+}

 pub struct EmbeddedServer {
    _srv_dir: Temp,
@ -13,29 +52,31 @@ pub struct EmbeddedServer {

 impl EmbeddedServer {
    /// Start embedded Grammalecte server on a random free port
-    pub fn start() -> Result<Self, Box<dyn Error>> {
-        Self::start_listen_on_port(get_free_port()?)
+    pub fn start() -> Result<Self, Error> {
+        Self::start_listen_on_port(get_free_port())
    }

    /// Start embedded Grammalecte server on a given port
-    pub fn start_listen_on_port(port: u16) -> Result<Self, Box<dyn Error>> {
+    pub fn start_listen_on_port(port: u16) -> Result<Self, Error> {
        log::info!("Will start server");
        // First, unpack server
-        let dest = mktemp::Temp::new_dir()?;
+        let dest = mktemp::Temp::new_dir().map_err(Error::CreateTempDir)?;
        let cursor = Cursor::new(include_bytes!("GrammalecteDist.zip"));
-        let mut zip = ZipArchive::new(cursor)?;
+        let mut zip = ZipArchive::new(cursor).map_err(Error::ZipArchiveLoading)?;
        for i in 0..zip.len() {
-            let mut file = zip.by_index(i)?;
+            let mut file = zip.by_index(i).map_err(Error::ZipFileIndex)?;
            if file.is_dir() {
                log::debug!("Create directory: {}", file.name());
-                std::fs::create_dir_all(dest.join(file.name()))?;
+                std::fs::create_dir_all(dest.join(file.name()))
+                    .map_err(Error::CreateDirectoryForZipFile)?;
            } else {
                log::debug!("Decompress file: {}", file.name());

                let mut buff = Vec::with_capacity(file.size() as usize);
-                file.read_to_end(&mut buff)?;
+                file.read_to_end(&mut buff)
+                    .map_err(Error::ZipFileReadToEnd)?;

-                std::fs::write(dest.join(file.name()), buff)?;
+                std::fs::write(dest.join(file.name()), buff).map_err(Error::WriteFile)?;
            }
        }

@ -48,15 +89,16 @@ impl EmbeddedServer {
        log::info!("Will execute file {}", server_file);

        // Start server
-        let child = std::process::Command::new("/usr/bin/python3")
+        let mut child = std::process::Command::new("/usr/bin/python3")
            .arg(server_file)
            .arg("-p")
            .arg(port.to_string())
            .stdout(Stdio::null())
-            .stderr(Stdio::null())
-            .spawn()?;
+            .stderr(Stdio::piped())
+            .spawn()
+            .map_err(Error::StartServerProcess)?;

-        wait_for_port(port)?;
+        wait_for_server(&mut child, port)?;

        Ok(Self {
            _srv_dir: dest,
@ -78,11 +120,14 @@ impl Drop for EmbeddedServer {
 }

 mod utils {
-    use std::io::ErrorKind;
+    use super::Error;
+    use std::fmt::Write;
+    use std::io::{BufRead, BufReader};
+    use std::process::Child;
    use std::time::Duration;

    /// Get a free port
-    pub fn get_free_port() -> std::io::Result<u16> {
+    pub fn get_free_port() -> u16 {
        let mut port = 0;

        while !(2000..=64000).contains(&port) {
@ -93,20 +138,42 @@ mod utils {
            port += 1;
        }

-        Ok(port)
+        port
    }

-    pub fn wait_for_port(port: u16) -> std::io::Result<()> {
+    pub fn wait_for_server(child: &mut Child, port: u16) -> Result<(), Error> {
        for _ in 0..50 {
+            check_server(child)?;
            if port_scanner::scan_port(port) {
                return Ok(());
            }
            std::thread::sleep(Duration::from_millis(100));
        }

-        Err(std::io::Error::new(
-            ErrorKind::Other,
-            format!("Port {} did not open in time!", port),
-        ))?
+        Err(Error::WaitPortOpen { port })
+    }
+
+    fn check_server(child: &mut Child) -> Result<(), Error> {
+        match child.try_wait().map_err(Error::ServerCheckStatus)? {
+            None => Ok(()), // Continue
+            Some(status) => {
+                if let Some(err) = child.stderr.take() {
+                    let mut msg = format!("grammalecte-server exit with `{status}`");
+                    writeln!(&mut msg, " :").unwrap();
+                    let err = BufReader::new(err);
+                    err.lines().for_each(|line| match line {
+                        Ok(line) => {
+                            writeln!(&mut msg, "\t{}", line).unwrap();
+                        }
+                        Err(err) => {
+                            writeln!(&mut msg, "__{err:?}").unwrap();
+                        }
+                    });
+                    Err(Error::ServerExitWithError { status, msg })
+                } else {
+                    Err(Error::ServerExitWithStatus { status })
+                }
+            }
+        }
    }
 }