Merge pull request #131 from Tim-Zhang/make-utils-private

Make unnecessarily public functions/mod private

Author: mxpv

example/async-server.rs

@@ -13,9 +13,9 @@ use std::sync::Arc;
 use log::LevelFilter;
 
 use protocols::r#async::{agent, agent_ttrpc, health, health_ttrpc, types};
-use ttrpc::asynchronous::server::*;
+use ttrpc::asynchronous::Server;
 use ttrpc::error::{Error, Result};
-use ttrpc::ttrpc::{Code, Status};
+use ttrpc::proto::{Code, Status};
 
 use async_trait::async_trait;
 use tokio::signal::unix::{signal, SignalKind};

example/client.rs

@@ -16,8 +16,8 @@ mod protocols;
 
 use protocols::sync::{agent, agent_ttrpc, health, health_ttrpc};
 use std::thread;
-use ttrpc::client::Client;
 use ttrpc::context::{self, Context};
+use ttrpc::Client;
 
 fn main() {
     let c = Client::connect("unix://@/tmp/1").unwrap();

example/server.rs

@@ -23,8 +23,8 @@ use std::thread;
 
 use protocols::sync::{agent, agent_ttrpc, health, health_ttrpc, types};
 use ttrpc::error::{Error, Result};
-use ttrpc::server::*;
-use ttrpc::ttrpc::{Code, Status};
+use ttrpc::proto::{Code, Status};
+use ttrpc::Server;
 
 struct HealthService;
 impl health_ttrpc::Health for HealthService {

src/asynchronous/client.rs

@@ -11,7 +11,7 @@ use std::sync::{Arc, Mutex};
 
 use crate::common::{client_connect, MESSAGE_TYPE_RESPONSE};
 use crate::error::{Error, Result};
-use crate::ttrpc::{Code, Request, Response};
+use crate::proto::{Code, Request, Response};
 
 use crate::asynchronous::stream::{receive, to_req_buf};
 use crate::r#async::utils;

src/asynchronous/mod.rs

@@ -5,16 +5,17 @@
 
 //! Server and client in async mode (alias r#async).
 
-pub mod client;
-pub mod server;
-pub mod stream;
+mod client;
+mod server;
+mod stream;
 #[macro_use]
-pub mod utils;
+#[doc(hidden)]
+mod utils;
 mod unix_incoming;
 
 #[doc(inline)]
 pub use crate::r#async::client::Client;
 #[doc(inline)]
 pub use crate::r#async::server::Server;
 #[doc(inline)]
-pub use crate::r#async::utils::{convert_response_to_buf, MethodHandler, TtrpcContext};
+pub use utils::{MethodHandler, TtrpcContext};

src/asynchronous/server.rs

@@ -16,8 +16,8 @@ use crate::asynchronous::unix_incoming::UnixIncoming;
 use crate::common::{self, Domain, MESSAGE_TYPE_REQUEST};
 use crate::context;
 use crate::error::{get_status, Error, Result};
+use crate::proto::{Code, Status};
 use crate::r#async::{MethodHandler, TtrpcContext};
-use crate::ttrpc::{Code, Status};
 use crate::MessageHeader;
 use futures::stream::Stream;
 use futures::StreamExt as _;
@@ -145,7 +145,7 @@ impl Server {
         }
     }
 
-    pub async fn do_start<I, S>(&mut self, mut incoming: I) -> Result<()>
+    async fn do_start<I, S>(&mut self, mut incoming: I) -> Result<()>
     where
         I: Stream<Item = std::io::Result<S>> + Unpin + Send + 'static + AsRawFd,
         S: AsyncRead + AsyncWrite + AsRawFd + Send + 'static,

src/asynchronous/stream.rs

@@ -7,8 +7,8 @@ use byteorder::{BigEndian, ByteOrder};
 
 use crate::common::{MESSAGE_HEADER_LENGTH, MESSAGE_LENGTH_MAX, MESSAGE_TYPE_RESPONSE};
 use crate::error::{get_rpc_status, sock_error_msg, Error, Result};
+use crate::proto::{Code, Response, Status};
 use crate::r#async::utils;
-use crate::ttrpc::{Code, Response, Status};
 use crate::MessageHeader;
 use protobuf::Message;
 use tokio::io::AsyncReadExt;
@@ -51,7 +51,7 @@ where
     Ok(mh)
 }
 
-pub async fn receive<T>(reader: &mut T) -> Result<(MessageHeader, Vec<u8>)>
+pub(crate) async fn receive<T>(reader: &mut T) -> Result<(MessageHeader, Vec<u8>)>
 where
     T: AsyncReadExt + std::marker::Unpin,
 {
@@ -94,15 +94,15 @@ fn header_to_buf(mh: MessageHeader) -> Vec<u8> {
     buf
 }
 
-pub fn to_req_buf(stream_id: u32, mut body: Vec<u8>) -> Vec<u8> {
+pub(crate) fn to_req_buf(stream_id: u32, mut body: Vec<u8>) -> Vec<u8> {
     let header = utils::get_request_header_from_body(stream_id, &body);
     let mut buf = header_to_buf(header);
     buf.append(&mut body);
 
     buf
 }
 
-pub fn to_res_buf(stream_id: u32, mut body: Vec<u8>) -> Vec<u8> {
+pub(crate) fn to_res_buf(stream_id: u32, mut body: Vec<u8>) -> Vec<u8> {
     let header = utils::get_response_header_from_body(stream_id, &body);
     let mut buf = header_to_buf(header);
     buf.append(&mut body);
@@ -119,7 +119,7 @@ fn get_response_body(res: &Response) -> Result<Vec<u8>> {
     Ok(buf)
 }
 
-pub async fn respond(
+pub(crate) async fn respond(
     tx: tokio::sync::mpsc::Sender<Vec<u8>>,
     stream_id: u32,
     body: Vec<u8>,
@@ -131,7 +131,7 @@ pub async fn respond(
         .map_err(err_to_others_err!(e, "Send packet to sender error "))
 }
 
-pub async fn respond_with_status(
+pub(crate) async fn respond_with_status(
     tx: tokio::sync::mpsc::Sender<Vec<u8>>,
     stream_id: u32,
     status: Status,

src/asynchronous/utils.rs

@@ -4,8 +4,8 @@
 //
 
 use crate::common::{MessageHeader, MESSAGE_TYPE_REQUEST, MESSAGE_TYPE_RESPONSE};
-use crate::error::{get_status, Error, Result};
-use crate::ttrpc::{Code, Request, Response, Status};
+use crate::error::{get_status, Result};
+use crate::proto::{Code, Request, Status};
 use async_trait::async_trait;
 use protobuf::{CodedInputStream, Message};
 use std::collections::HashMap;
@@ -47,7 +47,11 @@ macro_rules! async_request_handler {
             },
         }
 
-        let buf = ::ttrpc::r#async::convert_response_to_buf(res)?;
+        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(ttrpc::err_to_others!(e, ""))?;
+        s.flush().map_err(ttrpc::err_to_others!(e, ""))?;
+
         return Ok(($ctx.mh.stream_id, buf));
     };
 }
@@ -95,16 +99,7 @@ pub struct TtrpcContext {
     pub timeout_nano: i64,
 }
 
-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_err!(e, ""))?;
-    s.flush().map_err(err_to_others_err!(e, ""))?;
-
-    Ok(buf)
-}
-
-pub fn get_response_header_from_body(stream_id: u32, body: &[u8]) -> MessageHeader {
+pub(crate) fn get_response_header_from_body(stream_id: u32, body: &[u8]) -> MessageHeader {
     MessageHeader {
         length: body.len() as u32,
         stream_id,
@@ -113,7 +108,7 @@ pub fn get_response_header_from_body(stream_id: u32, body: &[u8]) -> MessageHead
     }
 }
 
-pub fn get_request_header_from_body(stream_id: u32, body: &[u8]) -> MessageHeader {
+pub(crate) fn get_request_header_from_body(stream_id: u32, body: &[u8]) -> MessageHeader {
     MessageHeader {
         length: body.len() as u32,
         stream_id,
@@ -122,7 +117,7 @@ pub fn get_request_header_from_body(stream_id: u32, body: &[u8]) -> MessageHeade
     }
 }
 
-pub fn new_unix_stream_from_raw_fd(fd: RawFd) -> UnixStream {
+pub(crate) fn new_unix_stream_from_raw_fd(fd: RawFd) -> UnixStream {
     let std_stream: std::os::unix::net::UnixStream;
     unsafe {
         std_stream = std::os::unix::net::UnixStream::from_raw_fd(fd);
@@ -133,7 +128,7 @@ pub fn new_unix_stream_from_raw_fd(fd: RawFd) -> UnixStream {
     UnixStream::from_std(std_stream).unwrap()
 }
 
-pub fn body_to_request(body: &[u8]) -> StdResult<Request, Status> {
+pub(crate) fn body_to_request(body: &[u8]) -> StdResult<Request, Status> {
     let mut req = Request::new();
     let merge_result;
     {
@@ -150,6 +145,6 @@ pub fn body_to_request(body: &[u8]) -> StdResult<Request, Status> {
     Ok(req)
 }
 
-pub fn get_path(service: &str, method: &str) -> String {
+pub(crate) fn get_path(service: &str, method: &str) -> String {
     format!("/{}/{}", service, method)
 }

src/common.rs

@@ -5,8 +5,6 @@
 
 //! Common functions and macros.
 
-#![allow(unused_macros)]
-
 use crate::error::{Error, Result};
 #[cfg(any(feature = "async", not(target_os = "linux")))]
 use nix::fcntl::FdFlag;

src/context.rs

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-use crate::ttrpc::KeyValue;
+use crate::proto::KeyValue;
 use std::collections::HashMap;
 
 #[derive(Clone, Default, Debug)]
@@ -78,7 +78,7 @@ pub fn to_pb(kvs: HashMap<String, Vec<String>>) -> protobuf::RepeatedField<KeyVa
 #[cfg(test)]
 mod tests {
     use crate::context;
-    use crate::ttrpc::KeyValue;
+    use crate::proto::KeyValue;
 
     #[test]
     fn test_metadata() {