Merge pull request #67 from Tim-Zhang/update-error

Update methods and macros related to error

Author: lifupan

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ttrpc"
-version = "0.4.8"
+version = "0.4.9"
 authors = ["The AntFin Kata Team <kata@list.alibaba-inc.com>"]
 edition = "2018"
 license = "Apache-2.0"

src/asynchronous/client.rs

@@ -148,8 +148,8 @@ impl Client {
         let mut buf = Vec::with_capacity(req.compute_size() as usize);
         {
             let mut s = CodedOutputStream::vec(&mut buf);
-            req.write_to(&mut s).map_err(err_to_Others!(e, ""))?;
-            s.flush().map_err(err_to_Others!(e, ""))?;
+            req.write_to(&mut s).map_err(err_to_others_err!(e, ""))?;
+            s.flush().map_err(err_to_others_err!(e, ""))?;
         }
 
         let (tx, mut rx): (ResponseSender, ResponseReceiver) = channel(100);
@@ -179,7 +179,7 @@ impl Client {
         let mut s = CodedInputStream::from_bytes(&buf);
         let mut res = Response::new();
         res.merge_from(&mut s)
-            .map_err(err_to_Others!(e, "Unpack response error "))?;
+            .map_err(err_to_others_err!(e, "Unpack response error "))?;
 
         let status = res.get_status();
         if status.get_code() != Code::OK {

src/asynchronous/stream.rs

@@ -41,10 +41,10 @@ where
     let mut mh = MessageHeader::default();
     let mut covbuf: &[u8] = &buf[..4];
     mh.length = byteorder::ReadBytesExt::read_u32::<BigEndian>(&mut covbuf)
-        .map_err(err_to_RpcStatus!(Code::INVALID_ARGUMENT, e, ""))?;
+        .map_err(err_to_rpc_err!(Code::INVALID_ARGUMENT, e, ""))?;
     let mut covbuf: &[u8] = &buf[4..8];
     mh.stream_id = byteorder::ReadBytesExt::read_u32::<BigEndian>(&mut covbuf)
-        .map_err(err_to_RpcStatus!(Code::INVALID_ARGUMENT, e, ""))?;
+        .map_err(err_to_rpc_err!(Code::INVALID_ARGUMENT, e, ""))?;
     mh.type_ = buf[8];
     mh.flags = buf[9];
 
@@ -113,8 +113,8 @@ pub fn to_res_buf(stream_id: u32, mut body: Vec<u8>) -> Vec<u8> {
 fn get_response_body(res: &Response) -> Result<Vec<u8>> {
     let mut buf = Vec::with_capacity(res.compute_size() as usize);
     let mut s = protobuf::CodedOutputStream::vec(&mut buf);
-    res.write_to(&mut s).map_err(err_to_Others!(e, ""))?;
-    s.flush().map_err(err_to_Others!(e, ""))?;
+    res.write_to(&mut s).map_err(err_to_others_err!(e, ""))?;
+    s.flush().map_err(err_to_others_err!(e, ""))?;
 
     Ok(buf)
 }
@@ -128,7 +128,7 @@ pub async fn respond(
 
     tx.send(buf)
         .await
-        .map_err(err_to_Others!(e, "Send packet to sender error "))
+        .map_err(err_to_others_err!(e, "Send packet to sender error "))
 }
 
 pub async fn respond_with_status(
@@ -152,5 +152,5 @@ pub async fn respond_with_status(
 
     tx.send(buf)
         .await
-        .map_err(err_to_Others!(e, "Send packet to sender error "))
+        .map_err(err_to_others_err!(e, "Send packet to sender error "))
 }

src/asynchronous/utils.rs

@@ -92,8 +92,8 @@ pub struct TtrpcContext {
 pub fn convert_response_to_buf(res: Response) -> Result<Vec<u8>> {
     let mut buf = Vec::with_capacity(res.compute_size() as usize);
     let mut s = protobuf::CodedOutputStream::vec(&mut buf);
-    res.write_to(&mut s).map_err(err_to_Others!(e, ""))?;
-    s.flush().map_err(err_to_Others!(e, ""))?;
+    res.write_to(&mut s).map_err(err_to_others_err!(e, ""))?;
+    s.flush().map_err(err_to_others_err!(e, ""))?;
 
     Ok(buf)
 }

src/common.rs

@@ -81,7 +81,7 @@ pub fn do_bind(host: &str) -> Result<(RawFd, Domain)> {
             .map_err(|e| Error::Socket(e.to_string()))?;
             let sockaddr_h = hostv[1].to_owned() + &"\x00".to_string();
             let sockaddr_u =
-                UnixAddr::new_abstract(sockaddr_h.as_bytes()).map_err(err_to_Others!(e, ""))?;
+                UnixAddr::new_abstract(sockaddr_h.as_bytes()).map_err(err_to_others_err!(e, ""))?;
             sockaddr = SockAddr::Unix(sockaddr_u);
         }
         Domain::Vsock => {
@@ -107,7 +107,7 @@ pub fn do_bind(host: &str) -> Result<(RawFd, Domain)> {
     };
 
     setsockopt(fd, sockopt::ReusePort, &true).ok();
-    bind(fd, &sockaddr).map_err(err_to_Others!(e, ""))?;
+    bind(fd, &sockaddr).map_err(err_to_others_err!(e, ""))?;
 
     Ok((fd, domain))
 }

src/error.rs

@@ -35,15 +35,15 @@ pub enum Error {
 pub type Result<T> = result::Result<T, Error>;
 
 /// Get ttrpc::Status from ttrpc::Code and a message.
-pub fn get_status(c: Code, msg: String) -> Status {
+pub fn get_status(c: Code, msg: impl ToString) -> Status {
     let mut status = Status::new();
     status.set_code(c);
-    status.set_message(msg);
+    status.set_message(msg.to_string());
 
     status
 }
 
-pub fn get_rpc_status(c: Code, msg: String) -> Error {
+pub fn get_rpc_status(c: Code, msg: impl ToString) -> Error {
     Error::RpcStatus(get_status(c, msg))
 }
 
@@ -56,13 +56,13 @@ pub fn sock_error_msg(size: usize, msg: String) -> Error {
     get_rpc_status(Code::INVALID_ARGUMENT, msg)
 }
 
-macro_rules! err_to_RpcStatus {
+macro_rules! err_to_rpc_err {
     ($c: expr, $e: ident, $s: expr) => {
         |$e| get_rpc_status($c, $s.to_string() + &$e.to_string())
     };
 }
 
-macro_rules! err_to_Others {
+macro_rules! err_to_others_err {
     ($e: ident, $s: expr) => {
         |$e| Error::Others($s.to_string() + &$e.to_string())
     };

src/sync/channel.rs

@@ -26,7 +26,7 @@ fn read_count(fd: RawFd, count: usize) -> Result<Vec<u8>> {
     let mut len = 0;
 
     if count == 0 {
-        return Ok(v.to_vec())
+        return Ok(v.to_vec());
     }
 
     loop {
@@ -54,7 +54,7 @@ fn write_count(fd: RawFd, buf: &[u8], count: usize) -> Result<usize> {
     let mut len = 0;
 
     if count == 0 {
-        return Ok(0)
+        return Ok(0);
     }
 
     loop {
@@ -92,12 +92,12 @@ fn read_message_header(fd: RawFd) -> Result<MessageHeader> {
     mh.length =
         covbuf
             .read_u32::<BigEndian>()
-            .map_err(err_to_RpcStatus!(Code::INVALID_ARGUMENT, e, ""))?;
+            .map_err(err_to_rpc_err!(Code::INVALID_ARGUMENT, e, ""))?;
     let mut covbuf: &[u8] = &buf[4..8];
     mh.stream_id =
         covbuf
             .read_u32::<BigEndian>()
-            .map_err(err_to_RpcStatus!(Code::INVALID_ARGUMENT, e, ""))?;
+            .map_err(err_to_rpc_err!(Code::INVALID_ARGUMENT, e, ""))?;
     mh.type_ = buf[8];
     mh.flags = buf[9];
 

src/sync/client.rs

@@ -173,31 +173,34 @@ impl Client {
     pub fn request(&self, req: Request) -> Result<Response> {
         let mut buf = Vec::with_capacity(req.compute_size() as usize);
         let mut s = CodedOutputStream::vec(&mut buf);
-        req.write_to(&mut s).map_err(err_to_Others!(e, ""))?;
-        s.flush().map_err(err_to_Others!(e, ""))?;
+        req.write_to(&mut s).map_err(err_to_others_err!(e, ""))?;
+        s.flush().map_err(err_to_others_err!(e, ""))?;
 
         let (tx, rx) = mpsc::sync_channel(0);
 
         self.sender_tx
             .send((buf, tx))
-            .map_err(err_to_Others!(e, "Send packet to sender error "))?;
+            .map_err(err_to_others_err!(e, "Send packet to sender error "))?;
 
         let result: Result<Vec<u8>>;
         if req.timeout_nano == 0 {
             result = rx
                 .recv()
-                .map_err(err_to_Others!(e, "Receive packet from recver error: "))?;
+                .map_err(err_to_others_err!(e, "Receive packet from recver error: "))?;
         } else {
             result = rx
                 .recv_timeout(Duration::from_nanos(req.timeout_nano as u64))
-                .map_err(err_to_Others!(e, "Receive packet from recver timeout: "))?;
+                .map_err(err_to_others_err!(
+                    e,
+                    "Receive packet from recver timeout: "
+                ))?;
         }
 
         let buf = result?;
         let mut s = CodedInputStream::from_bytes(&buf);
         let mut res = Response::new();
         res.merge_from(&mut s)
-            .map_err(err_to_Others!(e, "Unpack response error "))?;
+            .map_err(err_to_others_err!(e, "Unpack response error "))?;
 
         let status = res.get_status();
         if status.get_code() != Code::OK {

src/sync/utils.rs

@@ -17,16 +17,16 @@ pub fn response_to_channel(
 ) -> Result<()> {
     let mut buf = Vec::with_capacity(res.compute_size() as usize);
     let mut s = protobuf::CodedOutputStream::vec(&mut buf);
-    res.write_to(&mut s).map_err(err_to_Others!(e, ""))?;
-    s.flush().map_err(err_to_Others!(e, ""))?;
+    res.write_to(&mut s).map_err(err_to_others_err!(e, ""))?;
+    s.flush().map_err(err_to_others_err!(e, ""))?;
 
     let mh = MessageHeader {
         length: buf.len() as u32,
         stream_id,
         type_: MESSAGE_TYPE_RESPONSE,
         flags: 0,
     };
-    tx.send((mh, buf)).map_err(err_to_Others!(e, ""))?;
+    tx.send((mh, buf)).map_err(err_to_others_err!(e, ""))?;
 
     Ok(())
 }