rename

Author: Millione

volo-thrift/src/transport/incoming.rs

@@ -30,9 +30,3 @@ impl Stream for Incoming {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn test() {}
-}

volo-thrift/src/transport/multiplex/client.rs

@@ -157,7 +157,7 @@ where
             }
         }
         if cx.transport.should_reuse && resp.is_ok() {
-            if let Transport::Pooled(pooled) = transport {
+            if let Transport::TcpOrUnix(pooled) = transport {
                 pooled.reuse().await;
             }
         }

volo-thrift/src/transport/pingpong/client.rs

@@ -131,7 +131,7 @@ where
             .call((target, shmipc_target.clone(), Ver::PingPong))
             .await?;
         cx.stats.record_make_transport_end_at();
-        if let Transport::UnPooled(_) = transport {
+        if let Transport::Shm(_) = transport {
             cx.rpc_info
                 .caller_mut()
                 .set_transport(volo::net::shm::Transport(FastStr::new("shmipc")))

volo-thrift/src/transport/pingpong/server.rs

@@ -60,7 +60,7 @@ pub async fn serve<Svc, Req, Resp, E, D, SP>(
                         cx.rpc_info.caller_mut().set_address(peer_addr.clone());
                     } else {
                         cx.rpc_info
-                            .caller_mut()
+                            .callee_mut()
                             .set_transport(volo::net::shm::Transport(FastStr::new("shmipc")));
                         cx.rpc_info
                             .caller_mut()

volo-thrift/src/transport/pool/make_transport.rs

@@ -56,7 +56,7 @@ where
         let mt = self.inner.clone();
         if let Some(addr) = kv.1 {
             if let Ok(resp) = mt.call(addr.clone()).await {
-                return Ok(Transport::UnPooled(resp));
+                return Ok(Transport::Shm(resp));
             }
         }
         self.pool

volo-thrift/src/transport/pool/mod.rs

@@ -416,17 +416,17 @@ struct Idle<T> {
 }
 
 pub enum Transport<K: Key, T: Poolable> {
-    Pooled(Pooled<K, T>),
-    UnPooled(T),
+    TcpOrUnix(Pooled<K, T>),
+    Shm(T),
 }
 
 impl<E: Encoder, D: Decoder> Transport<Address, ThriftTransport<E, D>> {
     pub async fn reuse(self) {
         match self {
-            Transport::Pooled(pooled) => {
+            Transport::TcpOrUnix(pooled) => {
                 pooled.reuse().await;
             }
-            Transport::UnPooled(t) => {
+            Transport::Shm(t) => {
                 t.reuse().await;
             }
         }
@@ -435,30 +435,30 @@ impl<E: Encoder, D: Decoder> Transport<Address, ThriftTransport<E, D>> {
 
 impl<K: Key, T: Poolable> From<Pooled<K, T>> for Transport<K, T> {
     fn from(pooled: Pooled<K, T>) -> Self {
-        Transport::Pooled(pooled)
+        Transport::TcpOrUnix(pooled)
     }
 }
 
 impl<K: Key, T: Poolable> From<T> for Transport<K, T> {
     fn from(t: T) -> Self {
-        Transport::UnPooled(t)
+        Transport::Shm(t)
     }
 }
 
 impl<K: Key, T: Poolable> AsRef<T> for Transport<K, T> {
     fn as_ref(&self) -> &T {
         match self {
-            Transport::Pooled(pooled) => pooled.t.as_ref().expect("not dropped"),
-            Transport::UnPooled(t) => t,
+            Transport::TcpOrUnix(pooled) => pooled.t.as_ref().expect("not dropped"),
+            Transport::Shm(t) => t,
         }
     }
 }
 
 impl<K: Key, T: Poolable> AsMut<T> for Transport<K, T> {
     fn as_mut(&mut self) -> &mut T {
         match self {
-            Transport::Pooled(pooled) => pooled.t.as_mut().expect("not dropped"),
-            Transport::UnPooled(t) => t,
+            Transport::TcpOrUnix(pooled) => pooled.t.as_mut().expect("not dropped"),
+            Transport::Shm(t) => t,
         }
     }
 }