openiwan 0.3.0

An iWAN client and protocol library
Documentation
use crate::{Error, Result};
use std::io::Read;
use std::time::Duration;
use zeroize::Zeroize;

#[derive(Clone)]
pub struct HttpRequest {
    pub method: &'static str,
    pub url: String,
    pub headers: Vec<(String, String)>,
    pub body: Vec<u8>,
    pub timeout: Option<Duration>,
}

impl Drop for HttpRequest {
    fn drop(&mut self) {
        self.body.zeroize();
        for (_, value) in &mut self.headers {
            value.zeroize();
        }
    }
}

impl std::fmt::Debug for HttpRequest {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("HttpRequest")
            .field("method", &self.method)
            .field("url", &self.url)
            .field("headers", &"[REDACTED]")
            .field("body_length", &self.body.len())
            .field("timeout", &self.timeout)
            .finish()
    }
}

#[derive(Clone)]
pub struct HttpResponse {
    pub status: u16,
    pub body: Vec<u8>,
}

impl std::fmt::Debug for HttpResponse {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("HttpResponse")
            .field("status", &self.status)
            .field("body_length", &self.body.len())
            .finish()
    }
}

pub trait HttpTransport: Send + Sync {
    fn execute(&self, request: HttpRequest) -> Result<HttpResponse>;
}

pub struct UreqTransport {
    agent: ureq::Agent,
}

impl UreqTransport {
    pub fn new() -> Self {
        let timeout = Duration::from_secs(5);
        Self {
            agent: ureq::Agent::config_builder()
                .timeout_connect(Some(timeout))
                .timeout_recv_response(Some(timeout))
                .timeout_recv_body(Some(timeout))
                .http_status_as_error(false)
                .build()
                .new_agent(),
        }
    }
}

impl Default for UreqTransport {
    fn default() -> Self {
        Self::new()
    }
}

impl HttpTransport for UreqTransport {
    fn execute(&self, request: HttpRequest) -> Result<HttpResponse> {
        let response = match request.method {
            "GET" => {
                let mut builder = self.agent.get(&request.url);
                for (name, value) in &request.headers {
                    builder = builder.header(name, value);
                }
                if let Some(timeout) = request.timeout {
                    builder = builder.config().timeout_global(Some(timeout)).build();
                }
                builder.call()
            }
            "POST" => {
                let mut builder = self.agent.post(&request.url);
                for (name, value) in &request.headers {
                    builder = builder.header(name, value);
                }
                if let Some(timeout) = request.timeout {
                    builder = builder.config().timeout_global(Some(timeout)).build();
                }
                builder.send(&request.body)
            }
            other => {
                return Err(Error::Http(format!("unsupported HTTP method {other}")));
            }
        };
        match response {
            Ok(response) => read_response(response),
            Err(error) => Err(Error::Http(format!("request failed: {error}"))),
        }
    }
}

fn read_response(mut response: ureq::http::Response<ureq::Body>) -> Result<HttpResponse> {
    let status = response.status().as_u16();
    let mut body = Vec::new();
    response.body_mut().as_reader().read_to_end(&mut body)?;
    Ok(HttpResponse { status, body })
}