Merge pull request #6 from Na-x4/feature/update-messages

Feature/update messages

Author: Na-x4

Cargo.lock

@@ -12,6 +12,7 @@ base64 = "0.13"
 encoding_rs = "0.8"
 getopts = "0.2.21"
 libloading = "0.7"
+optional_take = "0.1.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 threadpool = "1.8"

Cargo.toml

@@ -16,7 +16,7 @@
 // along with AquesTalk-proxy.  If not, see <https://www.gnu.org/licenses/>.
 
 mod connection;
-pub mod messages;
+mod messages;
 
 use std::collections::HashMap;
 use std::net::{TcpListener, TcpStream, ToSocketAddrs};

src/server.rs

@@ -1,11 +1,40 @@
 use std::collections::HashMap;
 use std::io::{Read, Write};
 
-use serde_json::Deserializer;
+use optional_take::io::Takable;
+use serde_json::{Deserializer, Value};
 
 use crate::aquestalk::AquesTalk;
 
-use super::messages::{Req, Res};
+use super::messages::{
+    Request, Response, ResponsePayload,
+    ResponseStatus::{self, *},
+};
+
+pub fn new_voice_type_error(voice_type: String) -> ResponsePayload {
+    ResponsePayload::AquestalkError {
+        code: None,
+        message: format!("不明な声種 ({})", voice_type),
+    }
+}
+
+pub fn new_limit_reached_error() -> ResponsePayload {
+    ResponsePayload::ConnectionError {
+        message: "Request is too long".to_string(),
+    }
+}
+
+fn write_response<W>(
+    writer: &mut W,
+    status: ResponseStatus,
+    payload: ResponsePayload,
+    request: Option<Value>,
+) -> serde_json::Result<()>
+where
+    W: Write,
+{
+    serde_json::to_writer(writer, &Response::new(status, payload, request))
+}
 
 pub fn handle_connection<R, W>(
     reader: R,
@@ -17,33 +46,54 @@ where
     R: Read,
     W: Write,
 {
-    let reader: Box<dyn Read> = match limit {
-        Some(limit) => Box::new(reader.take(limit)),
-        None => Box::new(reader),
-    };
-    let reader = Deserializer::from_reader(reader).into_iter::<Req>();
-
-    for req in reader {
-        let req = match req {
-            Ok(req) => req,
-            Err(ref err) => {
-                serde_json::to_writer(&mut writer, &Res::from_error(err))?;
+    let mut reader = reader.take_optional(limit);
+
+    let deserializer = Deserializer::from_reader(&mut reader).into_iter::<Value>();
+    for request in deserializer {
+        let request = match request {
+            Ok(request) => request,
+            Err(err) => {
+                let payload = if err.is_eof() && reader.limit() == Some(0) {
+                    new_limit_reached_error()
+                } else {
+                    ResponsePayload::from(err)
+                };
+
+                write_response(&mut writer, Failure, payload, None)?;
                 break;
             }
         };
-        let aq = match aqtks.get(&req.voice_type) {
+
+        let write_response = {
+            let request = request.clone();
+            |status, payload| write_response(&mut writer, status, payload, Some(request))
+        };
+
+        let request: Request = match serde_json::from_value(request) {
+            Ok(request) => request,
+            Err(err) => {
+                write_response(Reusable, ResponsePayload::from(err))?;
+                continue;
+            }
+        };
+
+        let aq = match aqtks.get(&request.voice_type) {
             Some(aq) => aq,
             None => {
-                serde_json::to_writer(
-                    &mut writer,
-                    &Res::from_error_message(&format!("不明な声質 ({})", req.voice_type)),
-                )?;
+                write_response(Reusable, new_voice_type_error(request.voice_type))?;
+                continue;
+            }
+        };
+
+        let wav = match aq.synthe(&request.koe, request.speed) {
+            Ok(wav) => wav,
+            Err(err) => {
+                write_response(Reusable, ResponsePayload::from(err))?;
                 continue;
             }
         };
-        let wav = aq.synthe(&req.koe, req.speed);
 
-        serde_json::to_writer(&mut writer, &Res::from(wav))?;
+        write_response(Success, ResponsePayload::from(wav))?;
     }
 
     writer.flush()?;
@@ -52,8 +102,10 @@ where
 
 #[cfg(test)]
 mod test {
+    use serde_json::{json, Value};
+
     use super::handle_connection;
-    use crate::{aquestalk::load_libs, server::messages::Res};
+    use crate::aquestalk::load_libs;
 
     #[test]
     fn test_connection() {
@@ -62,12 +114,23 @@ mod test {
         let mut output = Vec::new();
 
         handle_connection(input, &mut output, libs, None).unwrap();
-        let output: Res = serde_json::from_str(&String::from_utf8(output).unwrap()).unwrap();
+        let mut response: Value =
+            serde_json::from_str(&String::from_utf8(output).unwrap()).unwrap();
+        if response["response"]["wav"].is_string() {
+            response["response"]["wav"] = json!("===WAV DATA===");
+        }
 
-        match output {
-            Res::Success { wav: _ } => (),
-            _ => unreachable!(),
-        };
+        assert_eq!(
+            response,
+            json!(
+                {
+                    "isSuccess": true,
+                    "isConnectionReusable": true,
+                    "response": { "type": "Wav", "wav": "===WAV DATA===" },
+                    "request": { "koe": "こんにちわ、せ'かい" }
+                }
+            )
+        );
     }
 
     #[test]
@@ -77,15 +140,21 @@ mod test {
         let mut output = Vec::new();
 
         handle_connection(input, &mut output, libs, Some(37)).unwrap();
-        let output: Res = serde_json::from_str(&String::from_utf8(output).unwrap()).unwrap();
+        let response: Value = serde_json::from_str(&String::from_utf8(output).unwrap()).unwrap();
 
-        match output {
-            Res::Error { ref message, code } => {
-                assert_eq!(code, None);
-                assert_eq!(message, "EOF while parsing an object at line 1 column 37");
-            }
-            _ => unreachable!(),
-        };
+        assert_eq!(
+            response,
+            json!(
+                {
+                    "isSuccess": false,
+                    "isConnectionReusable": false,
+                    "response": {
+                        "type": "ConnectionError",
+                        "message": "Request is too long"
+                    }
+                }
+            )
+        );
     }
 
     #[test]
@@ -95,15 +164,46 @@ mod test {
         let mut output = Vec::new();
 
         handle_connection(input, &mut output, libs, None).unwrap();
-        let output: Res = serde_json::from_str(&String::from_utf8(output).unwrap()).unwrap();
+        let response: Value = serde_json::from_str(&String::from_utf8(output).unwrap()).unwrap();
 
-        match output {
-            Res::Error { ref message, code } => {
-                assert_eq!(code, None);
-                assert_eq!(message, "EOF while parsing an object at line 1 column 37");
-            }
-            _ => unreachable!(),
-        };
+        assert_eq!(
+            response,
+            json!(
+                {
+                    "isConnectionReusable": false,
+                    "isSuccess": false,
+                    "response": {
+                        "type": "JsonError",
+                        "message": "EOF while parsing an object at line 1 column 37"
+                    }
+                }
+            )
+        );
+    }
+
+    #[test]
+    fn test_json_error_reusable() {
+        let libs = load_libs(&"./aquestalk").unwrap();
+        let input = "{\"koee\":\"こんにちわ、せ'かい\"}".as_bytes();
+        let mut output = Vec::new();
+
+        handle_connection(input, &mut output, libs, None).unwrap();
+        let response: Value = serde_json::from_str(&String::from_utf8(output).unwrap()).unwrap();
+
+        assert_eq!(
+            response,
+            json!(
+                {
+                    "isConnectionReusable": true,
+                    "isSuccess": false,
+                    "response": {
+                        "type": "JsonError",
+                        "message": "unknown field `koee`, expected one of `type`, `speed`, `koe`"
+                    },
+                    "request": { "koee": "こんにちわ、せ'かい" }
+                }
+            )
+        );
     }
 
     #[test]
@@ -113,15 +213,22 @@ mod test {
         let mut output = Vec::new();
 
         handle_connection(input, &mut output, libs, None).unwrap();
-        let output: Res = serde_json::from_str(&String::from_utf8(output).unwrap()).unwrap();
+        let response: Value = serde_json::from_str(&String::from_utf8(output).unwrap()).unwrap();
 
-        match output {
-            Res::Error { ref message, code } => {
-                assert_eq!(code, None);
-                assert_eq!(message, "不明な声質 (invalid type)");
-            }
-            _ => unreachable!(),
-        };
+        assert_eq!(
+            response,
+            json!(
+                {
+                    "isConnectionReusable": true,
+                    "isSuccess": false,
+                    "response": {
+                        "type": "AquestalkError",
+                        "message": "不明な声種 (invalid type)"
+                    },
+                    "request": { "type": "invalid type", "koe": "こんにちわ、せ'かい" }
+                }
+            )
+        );
     }
 
     #[test]
@@ -131,14 +238,22 @@ mod test {
         let mut output = Vec::new();
 
         handle_connection(input, &mut output, libs, None).unwrap();
-        let output: Res = serde_json::from_str(&String::from_utf8(output).unwrap()).unwrap();
+        let response: Value = serde_json::from_str(&String::from_utf8(output).unwrap()).unwrap();
 
-        match output {
-            Res::Error { ref message, code } => {
-                assert_eq!(code, Some(105));
-                assert_eq!(message, "音声記号列に未定義の読み記号が指定された");
-            }
-            _ => unreachable!(),
-        };
+        assert_eq!(
+            response,
+            json!(
+                {
+                    "isConnectionReusable": true,
+                    "isSuccess": false,
+                    "response": {
+                        "type": "AquestalkError",
+                        "code": 105,
+                        "message": "音声記号列に未定義の読み記号が指定された"
+                    },
+                    "request": { "koe": "🤔" }
+                }
+            )
+        );
     }
 }