Simplify traits

Remove Facts::Logger, use fixed type Arc<LogFilter>

Replace generic param from ClientTransport and ServerTransport with
associate type IO, so that don't need to specifiy in ClientPool/FailoverPool

The ClientFacts / ServerFacts inherit AsyncIO trait, through Deref and
blanket trait

Author: frostyplanet

Makefile

@@ -55,7 +55,7 @@ build: init
 	cargo build -p occams-rpc-stream-macros
 	cargo build -p occams-rpc-stream
 	cargo build -p occams-rpc-tcp
-	cargo build -p occams-rpc-test
+#	cargo build -p occams-rpc-test
 	cargo build
 
 .DEFAULT_GOAL = build

core/src/runtime.rs

@@ -39,7 +39,7 @@ pub trait AsyncFdTrait<T: AsRawFd + AsFd + Send + Sync + 'static>:
 /// Defines the interface we used from async runtime
 ///
 /// See module level doc: [crate::runtime]
-pub trait AsyncIO: Send + 'static {
+pub trait AsyncIO: Send + Sync + 'static {
     type Interval: TimeInterval;
 
     type AsyncFd<T: AsRawFd + AsFd + Send + Sync + 'static>: AsyncFdTrait<T>;
@@ -73,6 +73,60 @@ pub trait AsyncIO: Send + 'static {
     fn to_async_fd_rw<T: AsRawFd + AsFd + Send + Sync + 'static>(
         fd: T,
     ) -> io::Result<Self::AsyncFd<T>>;
+
+    /// You may spawn with globally runtime, or to a owned runtime executor
+    fn spawn_detach<F, R>(&self, f: F)
+    where
+        F: Future<Output = R> + Send + 'static,
+        R: Send + 'static;
+}
+
+impl<F: std::ops::Deref<Target = IO> + Send + Sync + 'static, IO: AsyncIO> AsyncIO for F {
+    type Interval = IO::Interval;
+
+    type AsyncFd<T: AsRawFd + AsFd + Send + Sync + 'static> = IO::AsyncFd<T>;
+
+    #[inline]
+    fn sleep(d: Duration) -> impl Future + Send {
+        IO::sleep(d)
+    }
+
+    #[inline]
+    fn tick(d: Duration) -> Self::Interval {
+        IO::tick(d)
+    }
+
+    fn connect_tcp(
+        addr: &SocketAddr, timeout: Duration,
+    ) -> impl Future<Output = io::Result<Self::AsyncFd<TcpStream>>> + Send {
+        IO::connect_tcp(addr, timeout)
+    }
+
+    fn connect_unix(
+        addr: &PathBuf, timeout: Duration,
+    ) -> impl Future<Output = io::Result<Self::AsyncFd<UnixStream>>> + Send {
+        IO::connect_unix(addr, timeout)
+    }
+
+    fn to_async_fd_rd<T: AsRawFd + AsFd + Send + Sync + 'static>(
+        fd: T,
+    ) -> io::Result<Self::AsyncFd<T>> {
+        IO::to_async_fd_rd(fd)
+    }
+
+    fn to_async_fd_rw<T: AsRawFd + AsFd + Send + Sync + 'static>(
+        fd: T,
+    ) -> io::Result<Self::AsyncFd<T>> {
+        IO::to_async_fd_rw(fd)
+    }
+
+    fn spawn_detach<FR, R>(&self, f: FR)
+    where
+        FR: Future<Output = R> + Send + 'static,
+        R: Send + 'static,
+    {
+        IO::spawn_detach(self.deref(), f)
+    }
 }
 
 /// Defines the universal interval/ticker trait

runtime/smol/Cargo.toml

@@ -18,6 +18,7 @@ with a low-level streaming interface, and high-level remote API call interface.
 [dependencies]
 futures = "0.3"
 occams-rpc-core = { path = "../../core/", version="0" }
+occams-rpc-stream = { path = "../../stream", version="0" }
 async-io = "2.6"
 async-executor = "1"
 smol = {version="2", optional=true}

runtime/smol/src/lib.rs

@@ -7,6 +7,7 @@
 //! It implements the [`AsyncIO`](https://docs.rs/occams-rpc-core/latest/occams_rpc_core/runtime/index.html) trait to support `async-io` of `smol`.
 
 use async_executor::Executor;
+use async_io::{Async, Timer};
 use occams_rpc_core::io::*;
 use occams_rpc_core::runtime::{AsyncFdTrait, AsyncIO, TimeInterval};
 use std::future::Future;
@@ -22,8 +23,6 @@ use std::sync::Arc;
 use std::task::*;
 use std::time::{Duration, Instant};
 
-use async_io::{Async, Timer};
-
 /// The main struct for async-io, assign this type to AsyncIO trait when used:
 ///
 /// - [ClientFactory::IO](https://occams-rpc-stream/latest/occams-rpc-stream/client/trait.ClientFactory.html)
@@ -42,25 +41,6 @@ impl SmolRT {
     pub fn new(executor: Arc<Executor<'static>>) -> Self {
         Self(Some(executor))
     }
-
-    #[inline]
-    pub fn spawn_detach<F, R>(&self, f: F)
-    where
-        F: Future<Output = R> + Send + 'static,
-        R: Send + 'static,
-    {
-        if let Some(executor) = self.0.as_ref() {
-            executor.spawn(f).detach();
-        } else {
-            #[cfg(feature = "global")]
-            {
-                smol::spawn(f).detach();
-                return;
-            }
-            #[cfg(not(feature = "global"))]
-            unreachable!();
-        }
-    }
 }
 
 impl AsyncIO for SmolRT {
@@ -112,6 +92,25 @@ impl AsyncIO for SmolRT {
     ) -> io::Result<Self::AsyncFd<T>> {
         Ok(SmolFD(Async::new(fd)?))
     }
+
+    #[inline]
+    fn spawn_detach<F, R>(&self, f: F)
+    where
+        F: Future<Output = R> + Send + 'static,
+        R: Send + 'static,
+    {
+        if let Some(executor) = self.0.as_ref() {
+            executor.spawn(f).detach();
+        } else {
+            #[cfg(feature = "global")]
+            {
+                smol::spawn(f).detach();
+                return;
+            }
+            #[cfg(not(feature = "global"))]
+            unreachable!();
+        }
+    }
 }
 
 /// Associate type for SmolRT
@@ -153,3 +152,5 @@ impl<T: AsRawFd + AsFd + Send + Sync + 'static> Deref for SmolFD<T> {
         self.0.get_ref()
     }
 }
+
+pub type ClientDefault<T, C> = occams_rpc_stream::client::ClientDefault<T, SmolRT, C>;

runtime/tokio/Cargo.toml

@@ -18,6 +18,7 @@ with a low-level streaming interface, and high-level remote API call interface.
 [dependencies]
 tokio = { version = "1", features = ["net", "time", "rt"] }
 occams-rpc-core = { path = "../../core/", version="0" }
+occams-rpc-stream = { path = "../../stream", version="0" }
 
 [package.metadata.docs.rs]
 all-features = true

runtime/tokio/src/lib.rs

@@ -33,15 +33,6 @@ impl TokioRT {
     pub fn new(handle: Handle) -> Self {
         Self(handle)
     }
-
-    #[inline]
-    pub fn spawn_detach<F, R>(&self, f: F)
-    where
-        F: Future<Output = R> + Send + 'static,
-        R: Send + 'static,
-    {
-        self.0.spawn(f);
-    }
 }
 
 impl AsyncIO for TokioRT {
@@ -94,6 +85,15 @@ impl AsyncIO for TokioRT {
         use tokio::io::Interest;
         Ok(TokioFD(io::unix::AsyncFd::with_interest(fd, Interest::READABLE | Interest::WRITABLE)?))
     }
+
+    #[inline]
+    fn spawn_detach<F, R>(&self, f: F)
+    where
+        F: Future<Output = R> + Send + 'static,
+        R: Send + 'static,
+    {
+        self.0.spawn(f);
+    }
 }
 
 /// Associate type for TokioRT
@@ -134,3 +134,5 @@ impl<T: AsRawFd + AsFd + Send + Sync + 'static> Deref for TokioFD<T> {
         self.0.get_ref()
     }
 }
+
+pub type ClientDefault<T, C> = occams_rpc_stream::client::ClientDefault<T, TokioRT, C>;

src/client/facts.rs

@@ -1,7 +1,7 @@
-#[cfg(any(feature = "tokio", feature = "smol"))]
-mod facts;
-#[cfg(any(feature = "tokio", feature = "smol"))]
-pub use facts::*;
+#[cfg(feature = "tokio")]
+pub type APIClientDefault<C: Codec> = occams_rpc_tokio::ClientDefault<C, APIClientReq>;
+#[cfg(all(not(feature = "tokio"), feature = "smol"))]
+pub type APIClientDefault<C: Codec> = occams_rpc_smol::ClientDefault<C, APIClientReq>;
 
 mod task;
 pub use task::APIClientReq;
@@ -17,14 +17,16 @@ use occams_rpc_stream::client::{
 use std::fmt;
 use std::sync::Arc;
 
+pub type ClientDefault<IO, C> = occams_rpc_stream::client::ClientDefault<APIClientReq, IO, C>;
+
 pub trait APIClientFacts: ClientFacts<Task = APIClientReq> {
-    fn create_endpoint_async<T: ClientTransport<<Self as ClientFacts>::IO>>(
+    fn create_endpoint_async<T: ClientTransport>(
         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 ClientFacts>::IO>>(
+    fn create_endpoint_async_failover<T: ClientTransport>(
         self: Arc<Self>, addrs: Vec<String>, round_robin: bool, retry_limit: usize,
     ) -> AsyncEndpoint<Arc<FailoverPool<Self, T>>> {
         return AsyncEndpoint::new(Arc::new(FailoverPool::new(
@@ -36,13 +38,13 @@ pub trait APIClientFacts: ClientFacts<Task = APIClientReq> {
         )));
     }
 
-    fn create_endpoint_blocking<T: ClientTransport<<Self as ClientFacts>::IO>>(
+    fn create_endpoint_blocking<T: ClientTransport>(
         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 ClientFacts>::IO>>(
+    fn create_endpoint_blocking_failover<T: ClientTransport>(
         self: Arc<Self>, addrs: Vec<String>, round_robin: bool, retry_limit: usize,
     ) -> BlockingEndpoint<Arc<FailoverPool<Self, T>>> {
         return BlockingEndpoint::new(Arc::new(FailoverPool::new(