Struct async_curl::actor::CurlActor

source ·

pub struct CurlActor<H>where
    H: Handler + Debug + Send + 'static,
{ /* private fields */ }

Expand description

CurlActor is responsible for performing the contructed Easy2 object at the background to perform it asynchronously.

use async_curl::actor::CurlActor;
use curl::easy::{Easy2, Handler, WriteError};

#[derive(Debug, Clone, Default)]
pub struct ResponseHandler {
    data: Vec<u8>,
}

impl Handler for ResponseHandler {
    /// This will store the response from the server
    /// to the data vector.
    fn write(&mut self, data: &[u8]) -> Result<usize, WriteError> {
        self.data.extend_from_slice(data);
        Ok(data.len())
    }
}

impl ResponseHandler {
    /// Instantiation of the ResponseHandler
    /// and initialize the data vector.
    pub fn new() -> Self {
        Self::default()
    }

    /// This will consumed the object and
    /// give the data to the caller
    pub fn get_data(self) -> Vec<u8> {
        self.data
    }
}

let curl = CurlActor::new();
let mut easy2 = Easy2::new(ResponseHandler::new());

easy2.url("https://www.rust-lang.org").unwrap();
easy2.get(true).unwrap();

let response = curl.send_request(easy2).await.unwrap();
eprintln!("{:?}", response.get_ref());

Ok(())

Example for multiple request executed at the same time.

use async_curl::actor::CurlActor;
use curl::easy::{Easy2, Handler, WriteError};

#[derive(Debug, Clone, Default)]
pub struct ResponseHandler {
    data: Vec<u8>,
}

impl Handler for ResponseHandler {
    /// This will store the response from the server
    /// to the data vector.
    fn write(&mut self, data: &[u8]) -> Result<usize, WriteError> {
        self.data.extend_from_slice(data);
        Ok(data.len())
    }
}

impl ResponseHandler {
    /// Instantiation of the ResponseHandler
    /// and initialize the data vector.
    pub fn new() -> Self {
        Self::default()
    }

    /// This will consumed the object and
    /// give the data to the caller
    pub fn get_data(self) -> Vec<u8> {
        self.data
    }
}

let actor = CurlActor::new();
let mut easy2 = Easy2::new(ResponseHandler::new());
easy2.url("https://www.rust-lang.org").unwrap();
easy2.get(true).unwrap();

let actor1 = actor.clone();
let spawn1 = tokio::spawn(async move {
    let response = actor1.send_request(easy2).await;
    let mut response = response.unwrap();

    // Response body
    eprintln!(
        "Task 1 : {}",
        String::from_utf8_lossy(&response.get_ref().to_owned().get_data())
    );
    // Response status code
    let status_code = response.response_code().unwrap();
    eprintln!("Task 1 : {}", status_code);
});

let mut easy2 = Easy2::new(ResponseHandler::new());
easy2.url("https://www.rust-lang.org").unwrap();
easy2.get(true).unwrap();

let spawn2 = tokio::spawn(async move {
    let response = actor.send_request(easy2).await;
    let mut response = response.unwrap();

    // Response body
    eprintln!(
        "Task 2 : {}",
        String::from_utf8_lossy(&response.get_ref().to_owned().get_data())
    );
    // Response status code
    let status_code = response.response_code().unwrap();
    eprintln!("Task 2 : {}", status_code);
});
let (_, _) = tokio::join!(spawn1, spawn2);

Ok(())

Implementations§

source §

impl<H> CurlActor<H>
where H: Handler + Debug + Send + 'static,

source

pub fn new() -> Self

This creates the new instance of CurlActor to handle Curl perform asynchronously using Curl Multi in a background thread to avoid blocking of other tasks.

source

pub async fn send_request(&self, easy2: Easy2<H>) -> Result<Easy2<H>, Error<H>>
where H: Handler + Debug + Send + 'static,

This will send Easy2 into the background task that will perform curl asynchronously, await the response in the oneshot receiver and return Easy2 back to the caller.