feat: deal with unwrap()

__enclave/virt_enclave/src/main.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 use warp::Filter;
 use serde::{ Serialize, Deserialize };
+use rust_util::XResult;
 
 include!("lib.rs");
 
@@ -59,40 +60,52 @@ async fn main() {
                 .and(warp::path!("call_js" / String))
                 .and(warp::body::json())
                 .map(|js_hex, call_js_body: CallJSBody| {
-        let js_fn = format!("js/{}.js", js_hex);
+        let the_fn = || -> XResult<String> {
-        let js_sig_fn = format!("js/{}.sig.json", js_hex);
+            let js_fn = format!("js/{}.js", js_hex);
-        let js = read_file(&js_fn).unwrap();
+            let js_sig_fn = format!("js/{}.sig.json", js_hex);
-        let js_sig = read_file(&js_sig_fn).unwrap();
+            let js = read_file(&js_fn)?;
+            let js_sig = read_file(&js_sig_fn)?;
+
+            let signed_message: SignedMessage = serde_json::from_str(&js_sig)?;
+            if !signed_message.verify(&load_signing_key_pair()?.public_key()) {
+                let mut result = HashMap::new();
+                result.insert("status", "400".to_owned());
+                result.insert("message", "Script verify failed!".to_owned());
+                result.insert("js_hash", format!("{}", js_hex));
+                return Ok(serde_json::to_string_pretty(&result)?);
+            }
+
+            let context = QuickJSContext::new()?;
+            context.init(&js)?;
+
+            let r = context.call_fn(&call_js_body.method, &call_js_body.params.unwrap_or_else(|| "[]".to_owned()));
         
-        let signed_message: SignedMessage = serde_json::from_str(&js_sig).unwrap();
-        if !signed_message.verify(&load_signing_key_pair().unwrap().public_key()) {
             let mut result = HashMap::new();
-            result.insert("status", "400".to_owned());
-            result.insert("message", "Script verify failed!".to_owned());
             result.insert("js_hash", format!("{}", js_hex));
-            return serde_json::to_string_pretty(&result).unwrap();
+            match r {
-        }
+                Err(e) => {
-
+                    result.insert("status", "500".to_owned());
-        let context = QuickJSContext::new().unwrap();
+                    result.insert("message", "Script call failed!".to_owned());
-        context.init(&js).unwrap();
+                    result.insert("result", format!("{}", e));
-
+                },
-        let r = context.call_fn(&call_js_body.method, &call_js_body.params.unwrap_or_else(|| "[]".to_owned()));
+                Ok(r) => {
-    
+                    result.insert("status", "200".to_owned());
-        let mut result = HashMap::new();
+                    result.insert("message", "Script call successed!".to_owned());
-        result.insert("js_hash", format!("{}", js_hex));
+                    result.insert("result", r.into_string().unwrap_or_else(|| "null".to_owned()));
-        match r {
+                },
+            }
+            Ok(serde_json::to_string_pretty(&result)?)
+        };
+        match the_fn() {
             Err(e) => {
+                let mut result = HashMap::new();
                 result.insert("status", "500".to_owned());
                 result.insert("message", "Script call failed!".to_owned());
                 result.insert("result", format!("{}", e));
+                serde_json::to_string_pretty(&result).unwrap_or_else(|e| format!("JSON ser error: {}", e))
             },
-            Ok(r) => {
+            Ok(r) => r,
-                result.insert("status", "200".to_owned());
-                result.insert("message", "Script call successed!".to_owned());
-                result.insert("result", r.into_string().unwrap_or_else(|| "null".to_owned()));
-            },
         }
-        serde_json::to_string_pretty(&result).unwrap()
     });
 
     println!("Listen at 127.0.0.1:8888 ...");

__enclave/virt_enclave/src/util.rs

@@ -4,15 +4,19 @@ use crate::sig::SigningKeyPair;
 use rust_util::XResult;
 
 lazy_static::lazy_static! {
-    static ref SIGNING_KEY_PAIR: Option<SigningKeyPair> = load_signing_key_pair();
+    static ref SIGNING_KEY_PAIR: Option<SigningKeyPair> = load_signing_key_pair_ok();
 }
 
 pub fn get_signing_public_key() -> Option<String> {
     SIGNING_KEY_PAIR.as_ref().map(|key_pair| hex::encode(&key_pair.public_key()))
 }
 
-pub fn load_signing_key_pair() -> Option<SigningKeyPair> {
+pub fn load_signing_key_pair() -> XResult<SigningKeyPair> {
-    SigningKeyPair::read_from_file("platform_signing_key.json").ok()
+    SigningKeyPair::read_from_file("platform_signing_key.json")
+}
+
+pub fn load_signing_key_pair_ok() -> Option<SigningKeyPair> {
+    load_signing_key_pair().ok()
 }
 
 pub fn read_file(f: &str) -> XResult<String> {