Rename ClientFactory->ClientFact

Author: frostyplanet

src/client/factory.rs

@@ -2,18 +2,18 @@ use super::task::APIClientReq;
 use super::{AsyncEndpoint, BlockingEndpoint};
 use captains_log::filter::LogFilter;
 use occams_rpc_core::{ClientConfig, Codec};
-use occams_rpc_stream::client::{ClientFactory, ClientPool, ClientTransport, FailoverPool};
+use occams_rpc_stream::client::{ClientFactory, ClientPool, ClientTransport};
 use std::sync::Arc;
 
 /// An example factory for API Clients
-pub struct APIClientFactory<C: Codec> {
+pub struct APIClientFactDefault<C: Codec> {
     pub logger: Arc<LogFilter>,
     config: ClientConfig,
     rt: crate::RT,
     _phan: std::marker::PhantomData<fn(&C)>,
 }
 
-impl<C: Codec> APIClientFactory<C> {
+impl<C: Codec> APIClientFactDefault<C> {
     pub fn new(config: ClientConfig, rt: crate::RT) -> Arc<Self> {
         Arc::new(Self { logger: Arc::new(LogFilter::new()), config, rt, _phan: Default::default() })
     }
@@ -22,45 +22,9 @@ impl<C: Codec> APIClientFactory<C> {
     pub fn set_log_level(&self, level: log::Level) {
         self.logger.set_level(level);
     }
-
-    pub fn create_endpoint_async<T: ClientTransport<crate::RT>>(
-        self: Arc<Self>, addr: &str,
-    ) -> AsyncEndpoint<ClientPool<Self, T>> {
-        return AsyncEndpoint::new(ClientPool::new(self.clone(), addr, 0));
-    }
-
-    pub fn create_endpoint_async_failover<T: ClientTransport<crate::RT>>(
-        self: Arc<Self>, addrs: Vec<String>, round_robin: bool, retry_limit: usize,
-    ) -> AsyncEndpoint<Arc<FailoverPool<Self, T>>> {
-        return AsyncEndpoint::new(Arc::new(FailoverPool::new(
-            self.clone(),
-            addrs,
-            round_robin,
-            retry_limit,
-            0,
-        )));
-    }
-
-    pub fn create_endpoint_blocking<T: ClientTransport<crate::RT>>(
-        self: Arc<Self>, addr: &str,
-    ) -> BlockingEndpoint<ClientPool<Self, T>> {
-        return BlockingEndpoint::new(ClientPool::new(self.clone(), addr, 0));
-    }
-
-    pub fn create_endpoint_blocking_failover<T: ClientTransport<crate::RT>>(
-        self: Arc<Self>, addrs: Vec<String>, round_robin: bool, retry_limit: usize,
-    ) -> BlockingEndpoint<Arc<FailoverPool<Self, T>>> {
-        return BlockingEndpoint::new(Arc::new(FailoverPool::new(
-            self.clone(),
-            addrs,
-            round_robin,
-            retry_limit,
-            0,
-        )));
-    }
 }
 
-impl<C: Codec> ClientFactory for APIClientFactory<C> {
+impl<C: Codec> ClientFactory for APIClientDefault<C> {
     type Logger = Arc<LogFilter>;
     type Codec = C;
     type Task = APIClientReq;

src/client/mod.rs

@@ -11,20 +11,61 @@ pub use occams_rpc_stream::client::ClientCaller;
 
 use occams_rpc_core::Codec;
 use occams_rpc_core::error::{EncodedErr, RpcErrCodec, RpcError, RpcIntErr};
-use occams_rpc_stream::client::{ClientCallerBlocking, ClientFactory};
+use occams_rpc_stream::client::{
+    ClientCallerBlocking, ClientFact, ClientPool, ClientTransport, FailoverPool,
+};
 use std::fmt;
+use std::sync::Arc;
+
+pub trait APIClientFact: ClientFact<Task = APIClientReq> {
+    fn create_endpoint_async<T: ClientTransport<<Self as ClientFact>::IO>>(
+        self: Arc<Self>, addr: &str,
+    ) -> AsyncEndpoint<ClientPool<Self, T>> {
+        return AsyncEndpoint::new(ClientPool::new(self.clone(), addr, 0));
+    }
+
+    fn create_endpoint_async_failover<T: ClientTransport<<Self as ClientFact>::IO>>(
+        self: Arc<Self>, addrs: Vec<String>, round_robin: bool, retry_limit: usize,
+    ) -> AsyncEndpoint<Arc<FailoverPool<Self, T>>> {
+        return AsyncEndpoint::new(Arc::new(FailoverPool::new(
+            self.clone(),
+            addrs,
+            round_robin,
+            retry_limit,
+            0,
+        )));
+    }
+
+    fn create_endpoint_blocking<T: ClientTransport<<Self as ClientFact>::IO>>(
+        self: Arc<Self>, addr: &str,
+    ) -> BlockingEndpoint<ClientPool<Self, T>> {
+        return BlockingEndpoint::new(ClientPool::new(self.clone(), addr, 0));
+    }
+
+    fn create_endpoint_blocking_failover<T: ClientTransport<<Self as ClientFact>::IO>>(
+        self: Arc<Self>, addrs: Vec<String>, round_robin: bool, retry_limit: usize,
+    ) -> BlockingEndpoint<Arc<FailoverPool<Self, T>>> {
+        return BlockingEndpoint::new(Arc::new(FailoverPool::new(
+            self.clone(),
+            addrs,
+            round_robin,
+            retry_limit,
+            0,
+        )));
+    }
+}
 
 pub struct AsyncEndpoint<C>
 where
-    C: ClientCaller<Factory: ClientFactory<Task = APIClientReq>>,
+    C: ClientCaller<Factory: ClientFact<Task = APIClientReq>>,
 {
     caller: C,
-    codec: <C::Factory as ClientFactory>::Codec,
+    codec: <C::Factory as ClientFact>::Codec,
 }
 
 impl<C> AsyncEndpoint<C>
 where
-    C: ClientCaller<Factory: ClientFactory<Task = APIClientReq>>,
+    C: ClientCaller<Factory: ClientFact<Task = APIClientReq>>,
 {
     pub fn new(caller: C) -> Self {
         Self { caller, codec: Default::default() }
@@ -48,7 +89,7 @@ where
 
 impl<C> Clone for AsyncEndpoint<C>
 where
-    C: Clone + ClientCaller<Factory: ClientFactory<Task = APIClientReq>>,
+    C: Clone + ClientCaller<Factory: ClientFact<Task = APIClientReq>>,
 {
     fn clone(&self) -> Self {
         Self::new(self.caller.clone())
@@ -57,7 +98,7 @@ where
 
 impl<C> std::ops::Deref for AsyncEndpoint<C>
 where
-    C: ClientCaller<Factory: ClientFactory<Task = APIClientReq>>,
+    C: ClientCaller<Factory: ClientFact<Task = APIClientReq>>,
 {
     type Target = C;
 
@@ -68,15 +109,15 @@ where
 
 pub struct BlockingEndpoint<C>
 where
-    C: ClientCallerBlocking<Factory: ClientFactory<Task = APIClientReq>>,
+    C: ClientCallerBlocking<Factory: ClientFact<Task = APIClientReq>>,
 {
     caller: C,
-    codec: <C::Factory as ClientFactory>::Codec,
+    codec: <C::Factory as ClientFact>::Codec,
 }
 
 impl<C> BlockingEndpoint<C>
 where
-    C: ClientCallerBlocking<Factory: ClientFactory<Task = APIClientReq>>,
+    C: ClientCallerBlocking<Factory: ClientFact<Task = APIClientReq>>,
 {
     fn new(caller: C) -> Self {
         Self { caller, codec: Default::default() }
@@ -99,7 +140,7 @@ where
 
 impl<C> Clone for BlockingEndpoint<C>
 where
-    C: Clone + ClientCallerBlocking<Factory: ClientFactory<Task = APIClientReq>>,
+    C: Clone + ClientCallerBlocking<Factory: ClientFact<Task = APIClientReq>>,
 {
     fn clone(&self) -> Self {
         Self::new(self.caller.clone())
@@ -108,7 +149,7 @@ where
 
 impl<C> std::ops::Deref for BlockingEndpoint<C>
 where
-    C: ClientCallerBlocking<Factory: ClientFactory<Task = APIClientReq>>,
+    C: ClientCallerBlocking<Factory: ClientFact<Task = APIClientReq>>,
 {
     type Target = C;
 

stream/src/client/failover.rs

@@ -1,7 +1,5 @@
 use crate::client::task::*;
-use crate::client::{
-    ClientCaller, ClientCallerBlocking, ClientFactory, ClientPool, ClientTransport,
-};
+use crate::client::{ClientCaller, ClientCallerBlocking, ClientFact, ClientPool, ClientTransport};
 use crate::proto::RpcAction;
 use arc_swap::ArcSwapOption;
 use crossfire::*;
@@ -25,12 +23,12 @@ use std::sync::{
 /// don't clone FailoverPool as it has custom drop. FailoverPool should be put in Arc for usage.
 pub struct FailoverPool<F, P>(Arc<FailoverPoolInner<F, P>>)
 where
-    F: ClientFactory,
+    F: ClientFact,
     P: ClientTransport<F::IO>;
 
 struct FailoverPoolInner<F, P>
 where
-    F: ClientFactory,
+    F: ClientFact,
     P: ClientTransport<F::IO>,
 {
     pools: ArcSwapOption<ClusterConfig<F, P>>,
@@ -45,7 +43,7 @@ where
 
 struct ClusterConfig<F, P>
 where
-    F: ClientFactory,
+    F: ClientFact,
     P: ClientTransport<F::IO>,
 {
     pools: Vec<ClientPool<FailoverPoolInner<F, P>, P>>,
@@ -54,7 +52,7 @@ where
 
 impl<F, P> FailoverPool<F, P>
 where
-    F: ClientFactory,
+    F: ClientFact,
     P: ClientTransport<F::IO>,
 {
     pub fn new(
@@ -118,7 +116,7 @@ where
 
 impl<F, P> ClusterConfig<F, P>
 where
-    F: ClientFactory,
+    F: ClientFact,
     P: ClientTransport<F::IO>,
 {
     #[inline]
@@ -148,7 +146,7 @@ where
 
 impl<F, P> FailoverPoolInner<F, P>
 where
-    F: ClientFactory,
+    F: ClientFact,
     P: ClientTransport<F::IO>,
 {
     async fn retry_worker(
@@ -187,7 +185,7 @@ where
 
 impl<F, P> Drop for FailoverPool<F, P>
 where
-    F: ClientFactory,
+    F: ClientFact,
     P: ClientTransport<F::IO>,
 {
     fn drop(&mut self) {
@@ -196,9 +194,9 @@ where
     }
 }
 
-impl<F, P> ClientFactory for FailoverPoolInner<F, P>
+impl<F, P> ClientFact for FailoverPoolInner<F, P>
 where
-    F: ClientFactory,
+    F: ClientFact,
     P: ClientTransport<F::IO>,
 {
     type Logger = F::Logger;
@@ -244,7 +242,7 @@ where
 
 impl<F, P> ClientCaller for FailoverPool<F, P>
 where
-    F: ClientFactory,
+    F: ClientFact,
     P: ClientTransport<F::IO>,
 {
     type Factory = F;
@@ -275,7 +273,7 @@ where
 
 impl<F, P> ClientCallerBlocking for FailoverPool<F, P>
 where
-    F: ClientFactory,
+    F: ClientFact,
     P: ClientTransport<F::IO>,
 {
     type Factory = F;

stream/src/client/mod.rs

@@ -24,11 +24,11 @@ use std::sync::Arc;
 use std::{fmt, io};
 
 /// A trait implemented by the user for the client-side, to define the customizable plugin.
-pub trait ClientFactory: Send + Sync + Sized + 'static {
+pub trait ClientFact: Send + Sync + Sized + 'static {
     /// A [captains-log::filter::Filter](https://docs.rs/captains-log/latest/captains_log/filter/index.html) implementation
     /// The type that new_logger returns.
     ///
-    /// maybe a `Arc<LogFilter> or KeyFilter<Arc<LogFilter>>`
+    /// maybe a `Arc<LogFilter> or KeyFilter<Arc<LogFilter>>, or DummyFilter`
     type Logger: Filter + Send + Sync + 'static;
 
     /// Define the codec to serialization and deserialization
@@ -81,21 +81,21 @@ pub trait ClientFactory: Send + Sync + Sized + 'static {
 }
 
 pub trait ClientCaller: Send {
-    type Factory: ClientFactory;
+    type Factory: ClientFact;
     fn send_req(
-        &self, task: <Self::Factory as ClientFactory>::Task,
+        &self, task: <Self::Factory as ClientFact>::Task,
     ) -> impl Future<Output = ()> + Send;
 }
 
 pub trait ClientCallerBlocking: Send {
-    type Factory: ClientFactory;
-    fn send_req_blocking(&self, task: <Self::Factory as ClientFactory>::Task);
+    type Factory: ClientFact;
+    fn send_req_blocking(&self, task: <Self::Factory as ClientFact>::Task);
 }
 
 impl<C: ClientCaller + Send + Sync> ClientCaller for Arc<C> {
     type Factory = C::Factory;
     #[inline(always)]
-    async fn send_req(&self, task: <Self::Factory as ClientFactory>::Task) {
+    async fn send_req(&self, task: <Self::Factory as ClientFact>::Task) {
         self.as_ref().send_req(task).await
     }
 }
@@ -104,7 +104,7 @@ impl<C: ClientCallerBlocking + Send + Sync> ClientCallerBlocking for Arc<C> {
     type Factory = C::Factory;
 
     #[inline(always)]
-    fn send_req_blocking(&self, task: <Self::Factory as ClientFactory>::Task) {
+    fn send_req_blocking(&self, task: <Self::Factory as ClientFact>::Task) {
         self.as_ref().send_req_blocking(task);
     }
 }
@@ -115,7 +115,7 @@ impl<C: ClientCallerBlocking + Send + Sync> ClientCallerBlocking for Arc<C> {
 ///
 /// - [occams-rpc-tcp](https://docs.rs/occams-rpc-tcp): For TCP and Unix socket
 ///
-/// NOTE: we use IO in generic param instead of ClientFactory to break cycle dep.
+/// NOTE: we use IO in generic param instead of ClientFact to break cycle dep.
 /// because FailoverPool will rewrap the factory into its own.
 pub trait ClientTransport<IO: AsyncIO>: fmt::Debug + Send + Sized + 'static {
     /// How to establish an async connection.
@@ -126,20 +126,20 @@ pub trait ClientTransport<IO: AsyncIO>: fmt::Debug + Send + Sized + 'static {
     ) -> impl Future<Output = Result<Self, RpcIntErr>> + Send;
 
     /// Shutdown the write direction of the connection
-    fn close_conn<F: ClientFactory>(&self, logger: &F::Logger) -> impl Future<Output = ()> + Send;
+    fn close_conn<F: ClientFact>(&self, logger: &F::Logger) -> impl Future<Output = ()> + Send;
 
     /// Flush the request for the socket writer, if the transport has buffering logic
-    fn flush_req<F: ClientFactory>(
+    fn flush_req<F: ClientFact>(
         &self, logger: &F::Logger,
     ) -> impl Future<Output = io::Result<()>> + Send;
 
     /// Write out the encoded request task
-    fn write_req<'a, F: ClientFactory>(
+    fn write_req<'a, F: ClientFact>(
         &'a self, logger: &F::Logger, buf: &'a [u8], blob: Option<&'a [u8]>, need_flush: bool,
     ) -> impl Future<Output = io::Result<()>> + Send;
 
     /// Read the response and decode it from the socket, find and notify the registered ClientTask
-    fn read_resp<F: ClientFactory>(
+    fn read_resp<F: ClientFact>(
         &self, factory: &F, logger: &F::Logger, codec: &F::Codec, close_ch: Option<&MAsyncRx<()>>,
         task_reg: &mut ClientTaskTimer<F>,
     ) -> impl std::future::Future<Output = Result<bool, RpcIntErr>> + Send;