Struct HttpConnection 

pub struct HttpConnection<S> { /* private fields */ }

Async HTTP/1.1 keep-alive connection — pure transport.

Sends request bytes and reads response bytes over an async stream. All protocol logic lives in RequestWriter and ResponseReader.

Usage

use nexus_net::rest::RequestWriter;
use nexus_net::http::ResponseReader;
use nexus_async_net::rest::{HttpConnection, HttpConnectionBuilder};
use nexus_net::tls::TlsConfig;

let mut writer = RequestWriter::new("api.binance.com").unwrap();
let mut reader = ResponseReader::new(32 * 1024);
let tls = TlsConfig::new()?;
let mut conn = HttpConnectionBuilder::new()
    .tls(&tls)
    .connect("https://api.binance.com")
    .await?;

let req = writer.get("/orders").query("symbol", "BTC").finish()?;
let resp = conn.send(req, &mut reader).await?;

Implementations

impl<S: WireStream + Unpin> HttpConnection<S>

pub fn new(stream: S) -> Self

Wrap a pre-connected async stream.

pub fn builder() -> HttpConnectionBuilder

Create a builder.

pub async fn send<'r>( &mut self, req: Request<'_>, reader: &'r mut ResponseReader, ) -> Result<RestResponse<'r>, RestError>

Send a request and read the response.

Same API as Client::send but with .await on I/O.

pub fn is_poisoned(&self) -> bool

Whether the connection is poisoned.

pub fn stream(&self) -> &S

Access the underlying stream.

pub fn stream_mut(&mut self) -> &mut S

Mutable access to the underlying stream.