examples/multipart/src/main.rs

use std::cell::Cell;
use std::fs;
use std::io::Write;

use actix_multipart::{Field, Multipart, MultipartError};
use actix_web::{error, middleware, web, App, Error, HttpResponse, HttpServer};
use futures::future::{err, Either};
use futures::{Future, Stream};

pub struct AppState {
    pub counter: Cell<usize>,
}

pub fn save_file(field: Field) -> impl Future<Item = i64, Error = Error> {
    let file_path_string = "upload.png";
    let file = match fs::File::create(file_path_string) {
        Ok(file) => file,
        Err(e) => return Either::A(err(error::ErrorInternalServerError(e))),
    };
    Either::B(
        field
            .fold((file, 0i64), move |(mut file, mut acc), bytes| {
                // fs operations are blocking, we have to execute writes
                // on threadpool
                web::block(move || {
                    file.write_all(bytes.as_ref()).map_err(|e| {
                        println!("file.write_all failed: {:?}", e);
                        MultipartError::Payload(error::PayloadError::Io(e))
                    })?;
                    acc += bytes.len() as i64;
                    Ok((file, acc))
                })
                .map_err(|e: error::BlockingError<MultipartError>| {
                    match e {
                        error::BlockingError::Error(e) => e,
                        error::BlockingError::Canceled => MultipartError::Incomplete,
                    }
                })
            })
            .map(|(_, acc)| acc)
            .map_err(|e| {
                println!("save_file failed, {:?}", e);
                error::ErrorInternalServerError(e)
            }),
    )
}

pub fn upload(
    multipart: Multipart,
    counter: web::Data<Cell<usize>>,
) -> impl Future<Item = HttpResponse, Error = Error> {
    counter.set(counter.get() + 1);
    println!("{:?}", counter.get());

    multipart
        .map_err(error::ErrorInternalServerError)
        .map(|field| save_file(field).into_stream())
        .flatten()
        .collect()
        .map(|sizes| HttpResponse::Ok().json(sizes))
        .map_err(|e| {
            println!("failed: {}", e);
            e
        })
}

fn index() -> HttpResponse {
    let html = r#"<html>
        <head><title>Upload Test</title></head>
        <body>
            <form target="/" method="post" enctype="multipart/form-data">
                <input type="file" name="file"/>
                <input type="submit" value="Submit"></button>
            </form>
        </body>
    </html>"#;

    HttpResponse::Ok().body(html)
}

fn main() -> std::io::Result<()> {
    std::env::set_var("RUST_LOG", "actix_server=info,actix_web=info");
    env_logger::init();

    HttpServer::new(|| {
        App::new()
            .data(Cell::new(0usize))
            .wrap(middleware::Logger::default())
            .service(
                web::resource("/")
                    .route(web::get().to(index))
                    .route(web::post().to_async(upload)),
            )
    })
    .bind("127.0.0.1:8080")?
    .run()
}
upgrade example to actix-web 0.7 2018-07-16 08:36:53 +02:00			`use std::cell::Cell;`
upgrade to alpha.6 2019-04-14 19:34:41 +02:00			`use std::fs;`
better multipart example 2018-06-08 06:34:14 +02:00			`use std::io::Write;`

upgrade to alpha.6 2019-04-14 19:34:41 +02:00			`use actix_multipart::{Field, Multipart, MultipartError};`
update deps 2019-03-29 21:43:03 +01:00			`use actix_web::{error, middleware, web, App, Error, HttpResponse, HttpServer};`
Revert to alpha3 multipart example to avoid panic The alpha4 multipart example seems to cause a panic (as mentioned in #736). So this reverts to the alpha3 example, tweaked for the actix-multipart crate. https://github.com/actix/actix-web/issues/736 2019-04-08 16:33:35 +02:00			`use futures::future::{err, Either};`
upgrade actix-web to 0.6 2018-05-08 20:08:43 +02:00			`use futures::{Future, Stream};`
actix examples in actix release version 2018-04-13 03:18:42 +02:00
Update main.rs 2018-06-20 17:03:56 +02:00			`pub struct AppState {`
			`pub counter: Cell<usize>,`
			`}`

upgrade to alpha4 2019-04-08 08:39:45 +02:00			`pub fn save_file(field: Field) -> impl Future<Item = i64, Error = Error> {`
better multipart example 2018-06-08 06:34:14 +02:00			`let file_path_string = "upload.png";`
update to beta.1 2019-04-21 18:36:31 +02:00			`let file = match fs::File::create(file_path_string) {`
better multipart example 2018-06-08 06:34:14 +02:00			`Ok(file) => file,`
upgrade to alpha.6 2019-04-14 19:34:41 +02:00			`Err(e) => return Either::A(err(error::ErrorInternalServerError(e))),`
better multipart example 2018-06-08 06:34:14 +02:00			`};`
update deps 2019-03-29 21:43:03 +01:00			`Either::B(`
better multipart example 2018-06-08 06:34:14 +02:00			`field`
update to beta.1 2019-04-21 18:36:31 +02:00			`.fold((file, 0i64), move \|(mut file, mut acc), bytes\| {`
			`// fs operations are blocking, we have to execute writes`
			`// on threadpool`
			`web::block(move \|\| {`
upgrade to beta3 2019-05-05 06:52:24 +02:00			`file.write_all(bytes.as_ref()).map_err(\|e\| {`
			`println!("file.write_all failed: {:?}", e);`
			`MultipartError::Payload(error::PayloadError::Io(e))`
			`})?;`
multipart: fix size result calculation 2019-04-22 15:10:25 +02:00			`acc += bytes.len() as i64;`
update to beta.1 2019-04-21 18:36:31 +02:00			`Ok((file, acc))`
			`})`
			`.map_err(\|e: error::BlockingError<MultipartError>\| {`
			`match e {`
			`error::BlockingError::Error(e) => e,`
			`error::BlockingError::Canceled => MultipartError::Incomplete,`
			`}`
			`})`
better multipart example 2018-06-08 06:34:14 +02:00			`})`
update to beta.1 2019-04-21 18:36:31 +02:00			`.map(\|(_, acc)\| acc)`
better multipart example 2018-06-08 06:34:14 +02:00			`.map_err(\|e\| {`
			`println!("save_file failed, {:?}", e);`
			`error::ErrorInternalServerError(e)`
			`}),`
			`)`
			`}`

update deps 2019-03-29 21:43:03 +01:00			`pub fn upload(`
upgrade to alpha4 2019-04-08 08:39:45 +02:00			`multipart: Multipart,`
update deps 2019-03-29 21:43:03 +01:00			`counter: web::Data<Cell<usize>>,`
			`) -> impl Future<Item = HttpResponse, Error = Error> {`
Revert to alpha3 multipart example to avoid panic The alpha4 multipart example seems to cause a panic (as mentioned in #736). So this reverts to the alpha3 example, tweaked for the actix-multipart crate. https://github.com/actix/actix-web/issues/736 2019-04-08 16:33:35 +02:00			`counter.set(counter.get() + 1);`
			`println!("{:?}", counter.get());`

update deps 2019-03-29 21:43:03 +01:00			`multipart`
Revert to alpha3 multipart example to avoid panic The alpha4 multipart example seems to cause a panic (as mentioned in #736). So this reverts to the alpha3 example, tweaked for the actix-multipart crate. https://github.com/actix/actix-web/issues/736 2019-04-08 16:33:35 +02:00			`.map_err(error::ErrorInternalServerError)`
upgrade to alpha.6 2019-04-14 19:34:41 +02:00			`.map(\|field\| save_file(field).into_stream())`
Revert to alpha3 multipart example to avoid panic The alpha4 multipart example seems to cause a panic (as mentioned in #736). So this reverts to the alpha3 example, tweaked for the actix-multipart crate. https://github.com/actix/actix-web/issues/736 2019-04-08 16:33:35 +02:00			`.flatten()`
update deps 2019-03-29 21:43:03 +01:00			`.collect()`
Revert to alpha3 multipart example to avoid panic The alpha4 multipart example seems to cause a panic (as mentioned in #736). So this reverts to the alpha3 example, tweaked for the actix-multipart crate. https://github.com/actix/actix-web/issues/736 2019-04-08 16:33:35 +02:00			`.map(\|sizes\| HttpResponse::Ok().json(sizes))`
			`.map_err(\|e\| {`
			`println!("failed: {}", e);`
			`e`
update deps 2019-03-29 21:43:03 +01:00			`})`
better multipart example 2018-06-08 06:34:14 +02:00			`}`

update deps 2019-03-29 21:43:03 +01:00			`fn index() -> HttpResponse {`
better multipart example 2018-06-08 06:34:14 +02:00			`let html = r#"<html>`
			`<head><title>Upload Test</title></head>`
			`<body>`
			`<form target="/" method="post" enctype="multipart/form-data">`
			`<input type="file" name="file"/>`
			`<input type="submit" value="Submit"></button>`
			`</form>`
			`</body>`
			`</html>"#;`

update deps 2019-03-29 21:43:03 +01:00			`HttpResponse::Ok().body(html)`
actix examples in actix release version 2018-04-13 03:18:42 +02:00			`}`

update deps 2019-03-29 21:43:03 +01:00			`fn main() -> std::io::Result<()> {`
			`std::env::set_var("RUST_LOG", "actix_server=info,actix_web=info");`
better multipart example 2018-06-08 06:34:14 +02:00			`env_logger::init();`
actix examples in actix release version 2018-04-13 03:18:42 +02:00
update deps 2019-03-29 21:43:03 +01:00			`HttpServer::new(\|\| {`
			`App::new()`
			`.data(Cell::new(0usize))`
			`.wrap(middleware::Logger::default())`
			`.service(`
			`web::resource("/")`
			`.route(web::get().to(index))`
			`.route(web::post().to_async(upload)),`
			`)`
update more examples and rustfmt 2019-03-10 03:03:09 +01:00			`})`
update deps 2019-03-29 21:43:03 +01:00			`.bind("127.0.0.1:8080")?`
			`.run()`
actix examples in actix release version 2018-04-13 03:18:42 +02:00			`}`