README: example should refer to online doc

Author: frostyplanet

README.md

@@ -36,9 +36,14 @@ In an `RpcServer`, for each connection, there is one coroutine to read requests
 coroutine to write responses. Requests can be dispatched with a user-defined
 `Dispatch` trait implementation.
 
+### Builtin connection pools:
+
+  - [ClientPool](https://docs.rs/razor-stream/latest/razor_stream/client/struct.ClientPool.html): Auto scalable pool:
+  - [FailoverPool](https://docs.rs/razor-stream/latest/razor_stream/client/struct.FailoverPool.html): Fault-tolerance pool
+
 ## API call interface
 
-`razor-rpc` <https://docs.rs/razor-rpc>
+Detail document and example refer to the `razor-rpc` crate <https://docs.rs/razor-rpc>
 
 - Independent from async runtime (with plugins)
 - With service trait very similar to grpc / tarpc (stream in API interface is not supported
@@ -47,103 +52,3 @@ currently)
 wrapper
 - Each method can have different custom error type (requires the type implements [RpcErrCodec](https://docs.rs/razor-stream/latest/razor_stream/error/trait.RpcErrCodec.html))
 - based on razor-stream`: Full duplex in each connection, with sliding window threshold, allow maximizing throughput and lower cpu usage.
-
-(Warning: The API and feature is still evolving, might changed in the future)
-
-### Example
-
-```rust
-use razor_rpc::client::{endpoint_client, endpoint_async, APIClientReq, ClientConfig};
-use razor_rpc::server::{service, ServerConfig};
-use razor_rpc::error::RpcError;
-use razor_rpc_tcp::{TcpClient, TcpServer};
-use nix::errno::Errno;
-use std::future::Future;
-use std::sync::Arc;
-
-// 1. Choose the async runtime, and the codec
-type OurRt = orb_smol::SmolRT;
-type OurCodec = razor_rpc_codec::MsgpCodec;
-// 2. Choose transport
-type ServerProto = TcpServer<OurRt>;
-type ClientProto = TcpClient<OurRt>;
-
-// 3. Define the client struct and service trait
-endpoint_client!(CalculatorClient);
-
-#[endpoint_async(CalculatorClient)]
-pub trait CalculatorService {
-    // Method with unit error type using impl Future
-    fn add(&self, args: (i32, i32)) -> impl Future<Output = Result<i32, RpcError<()>>> + Send;
-
-    // Method with string error type using impl Future
-    fn div(&self, args: (i32, i32)) -> impl Future<Output = Result<i32, RpcError<String>>> + Send;
-
-    // Method with errno error type using impl Future
-    fn might_fail_with_errno(&self, value: i32) -> impl Future<Output = Result<i32, RpcError<Errno>>> + Send;
-}
-
-// 4. Server implementation, can use Arc with internal context, but we are a simple demo
-#[derive(Clone)]
-pub struct CalculatorServer;
-
-#[service]
-impl CalculatorService for CalculatorServer {
-    async fn add(&self, args: (i32, i32)) -> Result<i32, RpcError<()>> {
-        let (a, b) = args;
-        Ok(a + b)
-    }
-
-    async fn div(&self, args: (i32, i32)) -> Result<i32, RpcError<String>> {
-        let (a, b) = args;
-        if b == 0 {
-            Err(RpcError::User("division by zero".to_string()))
-        } else {
-            Ok(a / b)
-        }
-    }
-
-    async fn might_fail_with_errno(&self, value: i32) -> Result<i32, RpcError<Errno>> {
-        if value < 0 {
-            Err(RpcError::User(Errno::EINVAL))
-        } else {
-            Ok(value * 2)
-        }
-    }
-}
-
-fn setup_server() -> std::io::Result<String> {
-    // 5. Server setup with default ServerFacts
-    use razor_rpc::server::{RpcServer, ServerDefault};
-    let server_config = ServerConfig::default();
-    let mut server = RpcServer::new(ServerDefault::new(server_config, OurRt::new_global()));
-    // 6. dispatch
-    use razor_rpc::server::dispatch::Inline;
-    let disp = Inline::<OurCodec, _>::new(CalculatorServer);
-    // 7. Start listening
-    let actual_addr = server.listen::<ServerProto, _>("127.0.0.1:8082", disp)?;
-    Ok(actual_addr)
-}
-
-async fn use_client(server_addr: &str) {
-    use razor_rpc::client::*;
-    // 8. ClientFacts
-    let mut client_config = ClientConfig::default();
-    client_config.task_timeout = 5;
-    let rt = OurRt::new_global();
-    type OurFacts = APIClientDefault<OurRt, OurCodec>;
-    let client_facts = OurFacts::new(client_config, rt);
-    // 9. Create client connection pool
-    let pool: ClientPool<OurFacts, ClientProto> =
-        client_facts.create_pool_async::<ClientProto>(server_addr);
-    let client = CalculatorClient::new(pool);
-    // Call methods with different error types
-    if let Ok(r) = client.add((10, 20)).await {
-        assert_eq!(r, 30);
-    }
-    // This will return a string error, but connect might fail, who knows
-    if let Err(e) = client.div((10, 0)).await {
-        println!("error occurred: {}", e);
-    }
-}
-```