Add integrated server

src/lib.rs

@@ -1,6 +1,11 @@
+#[cfg(feature = "embedded-server")]
+use crate::server::EmbeddedServer;
 use std::collections::HashMap;
 use std::error::Error;
 
+#[cfg(feature = "embedded-server")]
+mod server;
+
 /// Spell check options
 #[derive(Hash, Debug, Eq, PartialEq)]
 pub enum GramOpt {
@@ -255,12 +260,17 @@ pub struct SuggestResult {
 
 pub struct GrammalecteClient {
     base_url: String,
+
+    #[cfg(feature = "embedded-server")]
+    _server: Option<EmbeddedServer>,
 }
 
 impl Default for GrammalecteClient {
     fn default() -> Self {
         Self {
             base_url: "http://localhost:8080".to_string(),
+            #[cfg(feature = "embedded-server")]
+            _server: None,
         }
     }
 }
@@ -270,9 +280,24 @@ impl GrammalecteClient {
     pub fn new(base_url: &str) -> Self {
         Self {
             base_url: base_url.to_string(),
+            #[cfg(feature = "embedded-server")]
+            _server: None,
         }
     }
 
+    /// Construct a new Grammalecte client, spinning up an associated
+    /// temporary web server.
+    ///
+    /// Python 3.7 or higher must is required at runtime
+    #[cfg(feature = "embedded-server")]
+    pub fn start_server() -> Result<Self, Box<dyn Error>> {
+        let server = EmbeddedServer::start()?;
+        Ok(Self {
+            base_url: server.base_url(),
+            _server: Some(server),
+        })
+    }
+
     /// Run spell check on text
     pub async fn spell_check(&self, text: &str) -> Result<CheckResult, Box<dyn Error>> {
         self.spell_check_with_options(text, HashMap::new()).await
@@ -327,6 +352,7 @@ impl GrammalecteClient {
 }
 
 #[cfg(test)]
+#[cfg(feature = "embedded-server")]
 mod test {
     use crate::{GramOpt, GrammalecteClient};
     use std::collections::HashMap;
@@ -336,7 +362,11 @@ mod test {
         let _ = env_logger::builder().is_test(true).try_init();
 
         let msg = "Les ange sont inssuportables!";
-        let res = GrammalecteClient::default().spell_check(msg).await.unwrap();
+        let res = GrammalecteClient::start_server()
+            .unwrap()
+            .spell_check(msg)
+            .await
+            .unwrap();
         println!("RESULT = {:#?}", res);
     }
 
@@ -347,7 +377,8 @@ mod test {
         let msg = "Bonjour !";
         let mut opts = HashMap::new();
         opts.insert(GramOpt::EspacesInsecables, false);
-        let res = GrammalecteClient::default()
+        let res = GrammalecteClient::start_server()
+            .unwrap()
             .spell_check_with_options(msg, opts)
             .await
             .unwrap();
@@ -359,7 +390,8 @@ mod test {
     async fn simple_suggestion() {
         let _ = env_logger::builder().is_test(true).try_init();
 
-        let res = GrammalecteClient::default()
+        let res = GrammalecteClient::start_server()
+            .unwrap()
             .suggest("bonjou")
             .await
             .unwrap();

src/server.rs

@@ -0,0 +1,107 @@
+use crate::server::utils::{get_free_port, wait_for_port};
+use mktemp::Temp;
+use std::error::Error;
+use std::io::{Cursor, Read};
+use std::process::Child;
+use zip::ZipArchive;
+
+pub struct EmbeddedServer {
+    _srv_dir: Temp,
+    port: u16,
+    child: Child,
+}
+
+impl EmbeddedServer {
+    /// Start embedded Grammalecte server
+    pub fn start() -> Result<Self, Box<dyn Error>> {
+        log::info!("Will start server");
+        // First, unpack server
+        let dest = mktemp::Temp::new_dir()?;
+        let cursor = Cursor::new(include_bytes!("GrammalecteDist.zip"));
+        let mut zip = ZipArchive::new(cursor)?;
+        for i in 0..zip.len() {
+            let mut file = zip.by_index(i)?;
+            if file.is_dir() {
+                log::debug!("Create directory: {}", file.name());
+                std::fs::create_dir_all(dest.join(file.name()))?;
+            } else {
+                log::debug!("Decompress file: {}", file.name());
+
+                let mut buff = Vec::with_capacity(file.size() as usize);
+                file.read_to_end(&mut buff)?;
+
+                std::fs::write(dest.join(file.name()), buff)?;
+            }
+        }
+
+        // Get a free port
+        let port = get_free_port()?;
+        log::info!("Will start to listen on port {}", port);
+
+        let server_file = dest
+            .join("grammalecte/grammalecte-server.py")
+            .to_string_lossy()
+            .to_string();
+        log::info!("Will execute file {}", server_file);
+
+        // Start server
+        let child = std::process::Command::new("/usr/bin/python3")
+            .arg(server_file)
+            .arg("-p")
+            .arg(port.to_string())
+            .spawn()?;
+
+        wait_for_port(port)?;
+
+        Ok(Self {
+            _srv_dir: dest,
+            port,
+            child,
+        })
+    }
+
+    /// Get embedde instance base URL
+    pub fn base_url(&self) -> String {
+        format!("http://localhost:{}", self.port)
+    }
+}
+
+impl Drop for EmbeddedServer {
+    fn drop(&mut self) {
+        let _ = self.child.kill();
+    }
+}
+
+mod utils {
+    use std::io::ErrorKind;
+    use std::time::Duration;
+
+    /// Get a free port
+    pub fn get_free_port() -> std::io::Result<u16> {
+        let mut port = 0;
+
+        while !(2000..=64000).contains(&port) {
+            port = rand::random::<u16>() % 64000;
+        }
+
+        while port_scanner::scan_port(port) {
+            port += 1;
+        }
+
+        Ok(port)
+    }
+
+    pub fn wait_for_port(port: u16) -> std::io::Result<()> {
+        for _ in 0..50 {
+            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),
+        ))?
+    }
+}