rust - pasos - mis formularios google

¿Cómo analizar formularios multiparte usando abonander/multipart con Rocket?

Question

Esto podría ser útil para mí :

No tengo idea de cómo se supone que vas a analizar un formulario de varias partes, además de hacerlo manualmente utilizando solo la cadena de datos sin procesar como entrada

Trataré de ajustar el ejemplo de Hyper, pero cualquier ayuda será muy apreciada.

Problemas relevantes:

• Soporte multipart formularios .
• cohete de apoyo

Answer 1

La principal abstracción de Rocket para los datos es el rasgo FromData . Teniendo en cuenta los datos POST y la solicitud, puede construir un tipo determinado:

pub trait FromData: Sized {
    type Error;
    fn from_data(request: &Request, data: Data) -> Outcome<Self, Self::Error>;
}

Entonces, solo es cuestión de leer la API para varias partes e insertar la pestaña A en la ranura B:

#![feature(plugin)]
#![plugin(rocket_codegen)]

extern crate rocket;
extern crate multipart;

#[post("/", data = "<upload>")]
fn index(upload: DummyMultipart) -> String {
    format!("I read this: {:?}", upload)
}

#[derive(Debug)]
struct DummyMultipart {
    alpha: String,
    one: i32,
    file: Vec<u8>,
}

use std::io::{Cursor, Read};
use rocket::{Request, Data, Outcome};
use rocket::data::{self, FromData};
use multipart::server::Multipart;

impl FromData for DummyMultipart {
    type Error = ();

    fn from_data(request: &Request, data: Data) -> data::Outcome<Self, Self::Error> {
        // All of these errors should be reported
        let ct = request.headers().get_one("Content-Type").expect("no content-type");
        let idx = ct.find("boundary=").expect("no boundary");
        let boundary = &ct[(idx + "boundary=".len())..];

        let mut d = Vec::new();
        data.stream_to(&mut d).expect("Unable to read");

        let mut mp = Multipart::with_body(Cursor::new(d), boundary);

        // Custom implementation parts

        let mut alpha = None;
        let mut one = None;
        let mut file = None;

        mp.foreach_entry(|mut entry| {
            match entry.name.as_str() {
                "alpha" => {
                    let t = entry.data.as_text().expect("not text");
                    alpha = Some(t.into());
                },
                "one" => {
                    let t = entry.data.as_text().expect("not text");
                    let n = t.parse().expect("not number");
                    one = Some(n);
                },
                "file" => {
                    let mut d = Vec::new();
                    let f = entry.data.as_file().expect("not file");
                    f.read_to_end(&mut d).expect("cant read");
                    file = Some(d);
                },
                other => panic!("No known key {}", other),
            }
        }).expect("Unable to iterate");

        let v = DummyMultipart {
            alpha: alpha.expect("alpha not set"),
            one: one.expect("one not set"),
            file: file.expect("file not set"),
        };

        // End custom

        Outcome::Success(v)
    }
}

fn main() {
    rocket::ignite().mount("/", routes![index]).launch();
}

Nunca utilicé ninguna de estas API hace aproximadamente una hora, por lo que no hay garantía de que sea una buena implementación. De hecho, todo el pánico por el error definitivamente significa que no es óptimo. Un uso de producción manejaría todos esos limpiamente.

Sin embargo, funciona:

$ curl -X POST -F alpha=omega -F one=2 -F file=@hello http://localhost:8000/
I read this: DummyMultipart { alpha: "omega", one: 2, file: [104, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 10] }

Una implementación avanzada permitiría cierta abstracción entre los datos específicos del usuario y los aspectos multiparte genéricos. Algo como Multipart<MyForm> sería agradable.

El autor de Rocket señala que esta solución permite a un usuario malintencionado POSTAR un archivo de tamaño infinito, lo que provocaría que la máquina se quedara sin memoria. Dependiendo del uso previsto, es posible que desee establecer algún tipo de límite en el número de bytes leídos, posiblemente escribiendo en el sistema de archivos en algún punto de interrupción.