CODEWITHSUNDEEP
ruststreamingrust-actix
David Tex
David Tex

Reputation: 87

How do I prevent a timeout problem while streaming large files with an actix-web proxy?

I would like to use actix-web as a simple proxy server, but when I'm using huge files in streaming mode, the server has a timeout error and only a small part of the file will be downloaded.

I'm really confused because this is a sample code from the actix-web examples!

extern crate actix;
extern crate actix_web;
extern crate env_logger;
extern crate futures;

use actix_web::{
    client, middleware, server, App, AsyncResponder, Body, Error, HttpMessage,
    HttpRequest, HttpResponse,
};
use futures::{Future, Stream};

/// Stream client request response and then send body to a server response
fn index(_req: &HttpRequest) -> Box<Future<Item = HttpResponse, Error = Error>> {
    client::ClientRequest::get("http://127.0.0.1:8081/")
        .finish().unwrap()
        .send()
        .map_err(Error::from)          // <- convert SendRequestError to an Error
        .and_then(
            |resp| resp.body()         // <- this is MessageBody type, resolves to complete body
                .from_err()            // <- convert PayloadError to an Error
                .and_then(|body| {     // <- we got complete body, now send as server response
                    Ok(HttpResponse::Ok().body(body))
                }))
        .responder()
}

/// streaming client request to a streaming server response
fn streaming(_req: &HttpRequest) -> Box<Future<Item = HttpResponse, Error = Error>> {
    // send client request
    client::ClientRequest::get("https://gemmei.ftp.acc.umu.se/debian-cd/current/amd64/iso-cd/debian-9.7.0-amd64-netinst.iso")
        .finish().unwrap()
        .send()                         // <- connect to host and send request
        .map_err(Error::from)           // <- convert SendRequestError to an Error
        .and_then(|resp| {              // <- we received client response
            Ok(HttpResponse::Ok()
               // read one chunk from client response and send this chunk to a server response
               // .from_err() converts PayloadError to an Error
               .body(Body::Streaming(Box::new(resp.payload().from_err()))))
        })
        .responder()
}

fn main() {
    ::std::env::set_var("RUST_LOG", "actix_web=info");
    env_logger::init();
    let sys = actix::System::new("http-proxy");

    server::new(|| {
        App::new()
            .middleware(middleware::Logger::default())
            .resource("/streaming", |r| r.f(streaming))
            .resource("/", |r| r.f(index))
    }).workers(1)
        .bind("127.0.0.1:8080")
        .unwrap()
        .start();

    println!("Started http server: 127.0.0.1:8080");
    let _ = sys.run();
}

Dependencies:

[dependencies]
env_logger = "0.5"
futures = "0.1"
actix = "0.7"
actix-web = { version="0.7", features=["ssl"] }

This code logs an error:

ERROR 2019-02-09T18:10:16Z: actix_web::pipeline: Error occurred during request handling: Timeout while waiting for response
ERROR 2019-02-09T18:10:16Z: actix_web::server::h1: Unhandled error1: Timeout while waiting for response

The downloaded data doesn't have the right content length and file name:

Sample Picture

Upvotes: 3

Views: 2859

Answers (1)

arve0
arve0

Reputation: 3647

You should stream the body: use .streaming instead of .body:

use actix_web::client::Client;
use actix_web::{web, App, Error, HttpResponse, HttpServer};
use futures::future::Future;

fn main() {
    HttpServer::new(|| {
        App::new()
            .data(Client::new())
            .route("/", web::to_async(handler))
    })
    .bind("127.0.0.1:8000")
    .expect("Cannot bind to port 8000")
    .run()
    .expect("Unable to run server");
}

fn handler(client: web::Data<Client>) -> impl Future<Item = HttpResponse, Error = Error> {
    client.get("https://gensho.ftp.acc.umu.se/debian-cd/current/amd64/iso-cd/debian-10.0.0-amd64-netinst.iso")
        .send()
        .map_err(Error::from)
        .and_then(|res| {
            HttpResponse::build(res.status()).streaming(res)
        })
}

For proxying, note that the proxy example has been updated to fix issues with the content length header.

Upvotes: 3

Related Questions