Just refer to the module docs from the readme

Author: rklaehn

Cargo.toml

@@ -55,10 +55,10 @@ n0-future = { version = "0.1.2" }
 # enable the remote transport
 rpc = ["dep:quinn", "dep:postcard", "dep:anyhow", "dep:smallvec", "dep:tracing", "tokio/io-util"]
 # add test utilities
-test = ["rpc", "dep:rustls", "dep:rcgen", "dep:anyhow", "dep:futures-buffered"]
+quinn_endpoint_setup = ["rpc", "dep:rustls", "dep:rcgen", "dep:anyhow", "dep:futures-buffered"]
 # pick up parent span when creating channel messages
 message_spans = []
-default = ["rpc", "test", "message_spans"]
+default = ["rpc", "quinn_endpoint_setup", "message_spans"]
 
 [workspace]
 members = ["quic-rpc-derive", "quic-rpc-iroh"]

README.md

@@ -13,73 +13,9 @@ A streaming rpc system based on quic
 [status link]: https://github.com/n0-computer/quic-rpc/actions/workflows/rust.yml
 [repo link]: https://github.com/n0-computer/quic-rpc
 
-## Goals
+# Goals
 
-### Interaction patterns
-
-Provide not just request/response RPC, but also streaming in both directions, similar to [grpc].
-
-- 1 req -> 1 res
-- 1 req, update stream -> 1 res
-- 1 req -> res stream
-- 1 req, update stream -> res stream
-
-It is still a RPC system in the sense that interactions get initiated by the client.
-
-### Transports
-
-- memory transport with very low overhead. In particular, no ser/deser, currently using [tokio channels]
-   when using tokio channels, there is zero overhead compared to just manually including backchannels in messages
-- quic transport via the [iroh-quinn] crate
-
-### API
-
-- The API should be similar to the quinn api. Basically "quinn with types".
-
-## Non-Goals
-
-- Cross language interop. This is for talking from rust to rust
-- Any kind of versioning. You have to do this yourself
-- Making remote message passing look like local async function calls
-- Being runtime agnostic. This is for tokio
-
-## Example
-
-[computation service](https://github.com/n0-computer/quic-rpc/blob/main/tests/math.rs)
-
-## Why?
-
-The purpose of quic-rpc is to serve as an *optional* rpc framework. One of the
-main goals is to be able to use it as an *in process* way to have well specified
-protocols and boundaries between subsystems, including an async boundary.
-
-It should not have noticeable overhead compared to what you would do anyway to
-isolate subsystems in a complex single process app, but should have the *option*
-to also send messages over a process boundary via one of the non mem transports.
-
-What do you usually do in rust to have isolation between subsystems, e.g.
-between a database and a networking layer? You have some kind of
-channel between the systems and define messages flowing back and forth over that
-channel. For almost all interactions these messages itself will again contain
-(oneshot or mpsc) channels for independent async communication between the
-subsystems.
-
-Quic-rpc with the mem channel does exactly the same thing, except that it
-distinguishes between the serializable protocol of a service and the full
-messages of a service that include unserializable channels.
-
-Instead of having a message that explicitly contains some data and the send side
-of a oneshot or mpsc channel for the response, it allows you to specify the
-channel kind and message type of the channels in both directions.
-
-For the case where you have a process boundary, the overhead is very low for
-transports that already have a concept of cheap substreams (http2, quic, ...).
-Quic is the poster child of a network transport that has built in cheap
-substreams including per substream backpressure.
-
-[iroh-quinn]: https://docs.rs/iroh-quinn/
-[tokio channels]: https://docs.rs/tokio/latest/tokio/sync/index.html
-[grpc]: https://grpc.io/
+See the [module docs](https://docs.rs/quic-rpc/latest/quic_rpc/).
 
 # Docs
 

src/util.rs

@@ -2,8 +2,8 @@
 //!
 //! This module contains utilities to read and write varints, as well as
 //! functions to set up quinn endpoints for local rpc and testing.
-#[cfg(feature = "test")]
-#[cfg_attr(quicrpc_docsrs, doc(cfg(feature = "test")))]
+#[cfg(feature = "quinn_endpoint_setup")]
+#[cfg_attr(quicrpc_docsrs, doc(cfg(feature = "quinn_endpoint_setup")))]
 mod quinn_setup_utils {
     use std::{net::SocketAddr, sync::Arc};
 
@@ -143,8 +143,8 @@ mod quinn_setup_utils {
         }
     }
 }
-#[cfg(feature = "test")]
-#[cfg_attr(quicrpc_docsrs, doc(cfg(feature = "test")))]
+#[cfg(feature = "quinn_endpoint_setup")]
+#[cfg_attr(quicrpc_docsrs, doc(cfg(feature = "quinn_endpoint_setup")))]
 pub use quinn_setup_utils::*;
 
 #[cfg(feature = "rpc")]