Make unnecessarily public functions/mod private

If the method is useless for users but it
used by generated code, just hide the docs.

Fixes: #130

Signed-off-by: Tim Zhang <[email protected]>

Author: Tim-Zhang

example/async-server.rs

@@ -13,7 +13,7 @@ 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};
 

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::Server;
 
 struct HealthService;
 impl health_ttrpc::Health for HealthService {

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/stream.rs

@@ -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::ttrpc::{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/lib.rs

@@ -52,7 +52,6 @@ mod common;
 mod compiled {
     include!(concat!(env!("OUT_DIR"), "/mod.rs"));
 }
-#[doc(inline)]
 pub use compiled::ttrpc;
 
 pub mod context;
@@ -66,22 +65,17 @@ pub use crate::ttrpc::{Code, Request, Response, Status};
 
 cfg_sync! {
     pub mod sync;
+    #[doc(hidden)]
+    pub use sync::response_to_channel;
     #[doc(inline)]
-    pub use crate::sync::channel::{write_message};
-    #[doc(inline)]
-    pub use crate::sync::utils::{response_to_channel, MethodHandler, TtrpcContext};
-    #[doc(inline)]
-    pub use crate::sync::client;
-    #[doc(inline)]
-    pub use crate::sync::client::Client;
-    #[doc(inline)]
-    pub use crate::sync::server;
+    pub use sync::{MethodHandler, TtrpcContext};
+    pub use sync::Client;
     #[doc(inline)]
-    pub use crate::sync::server::Server;
+    pub use sync::Server;
 }
 
 cfg_async! {
     pub mod asynchronous;
     #[doc(hidden)]
-    pub use crate::asynchronous as r#async;
+    pub use asynchronous as r#async;
 }

src/sync/client.rs

@@ -27,8 +27,8 @@ use std::{io, thread};
 use crate::common::set_fd_close_exec;
 use crate::common::{client_connect, MESSAGE_TYPE_REQUEST, MESSAGE_TYPE_RESPONSE, SOCK_CLOEXEC};
 use crate::error::{Error, Result};
-use crate::sync::channel::{read_message, write_message};
 use crate::ttrpc::{Code, Request, Response};
+use crate::sync::channel::{read_message, write_message};
 use crate::MessageHeader;
 use std::time::Duration;
 

src/sync/mod.rs

@@ -5,12 +5,16 @@
 
 //! Server and Client in sync mode.
 
-#[macro_use]
-pub mod channel;
-pub mod client;
-// TODO: address this after merging linters
-#[allow(clippy::too_many_arguments)]
-pub mod server;
+mod channel;
+mod client;
+mod server;
 
 #[macro_use]
-pub mod utils;
+mod utils;
+
+pub use client::Client;
+pub use server::Server;
+
+#[doc(hidden)]
+pub use utils::response_to_channel;
+pub use utils::{MethodHandler, TtrpcContext};

src/sync/server.rs

@@ -25,6 +25,7 @@ use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
 use std::{io, thread};
 
+use super::utils::response_to_channel;
 #[cfg(not(target_os = "linux"))]
 use crate::common::set_fd_close_exec;
 use crate::common::{self, MESSAGE_TYPE_REQUEST};
@@ -33,7 +34,7 @@ use crate::error::{get_status, Error, Result};
 use crate::sync::channel::{read_message, write_message};
 use crate::ttrpc::{Code, Request, Response};
 use crate::MessageHeader;
-use crate::{response_to_channel, MethodHandler, TtrpcContext};
+use crate::{MethodHandler, TtrpcContext};
 
 // poll_queue will create WAIT_THREAD_COUNT_DEFAULT threads in begin.
 // If wait thread count < WAIT_THREAD_COUNT_MIN, create number to WAIT_THREAD_COUNT_DEFAULT.
@@ -86,6 +87,7 @@ struct ThreadS<'a> {
     max: usize,
 }
 
+#[allow(clippy::too_many_arguments)]
 fn start_method_handler_thread(
     fd: RawFd,
     fdlock: Arc<Mutex<()>>,