concuring 0.1.0

A synchronous, concurrent HTTP client library for Rust that uses io_uring.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

//! # Concuring
//!
//! **Note: This library is a work in progress and is not yet suitable for production use.**
//!
//! `concuring` is a synchronous, concurrent HTTP client that uses a single blocking thread.
//!
//! ## Design and Motivation
//!
//! The primary goal of this library is to enable concurrent HTTP requests from a synchronous Rust application without pulling in an entire asynchronous runtime like `tokio` or `async-std`.
//!
//! While async provides a powerful model for concurrency, it can be "viral," often requiring significant parts of an application to be written in an async-aware style. For applications that are primarily synchronous, introducing async for networking can add significant complexity and binary size.
//!
//! `concuring` offers a different trade-off. It uses the Linux `io-uring` interface to perform asynchronous I/O operations in the kernel, while presenting a simple, blocking API to your application. This allows you to submit multiple requests and wait for them to complete concurrently, all from a single thread, keeping your application's architecture synchronous and simple.
//!
//! ### Trade-offs
//!
//! *   **Linux Only**: Relies on `io-uring`, which is a Linux-specific feature.
//! *   **Single-Threaded Concurrency**: Concurrency is handled by the kernel, but all application-level logic runs on the one thread that owns the `Concuring` client. This is not multi-threaded parallelism.
//!
//! ## Roadmap
//!
//! - [x] HTTP GET
//! - [x] Chunked responses
//! - [ ] Connection pooling
//! - [ ] TLS
//!

pub mod concuring;
pub mod request;

pub use concuring::Concuring;
pub use request::{Request, RequestBuilder};