initial multipart handling

author: Akshay <[email protected]> 2020-08-23 08:33:21 +0100
committer: Akshay <[email protected]> 2020-08-23 08:33:21 +0100
commit: 21f1d776762035012f02be39c96978b0719e0613 (patch)
tree: 24fd73624f305281c391825875dcaf941e716090 /src
parent: f36a8fb2eee46cffa87213e070136e5f28194a16 (diff)
1 files changed, 50 insertions, 22 deletions
diff --git a/src/main.rs b/src/main.rs
index cb76d5b..769ed03 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,6 +1,8 @@
 use anyhow::{Context, Result};
+use hyper::header::CONTENT_TYPE;
 use hyper::service::{make_service_fn, service_fn};
 use hyper::{Body, Method, Request, Response, Server, StatusCode};
+use multer::Multipart;
 use nanoid::nanoid;
 use rusqlite::{params, Connection, OpenFlags, NO_PARAMS};
 use url::form_urlencoded;
@@ -34,34 +36,62 @@ fn get_link<S: AsRef<str>>(url: S, conn: &mut Connection) -> Result<Option<Strin
    }
 }
+async fn process_multipart(body: Body, boundary: String) -> Result<Response<Body>> {
+    let mut m = Multipart::new(body, boundary);
+    if let Some(field) = m.next_field().await? {
+        let content = field
+            .text()
+            .await
+            .with_context(|| format!("Expected field name"))?;
+        eprintln!("{}", content);
+    }
+    Ok(Response::builder()
+        .status(StatusCode::OK)
+        .body(Body::empty())?)
+}
 async fn shortner_service(req: Request<Body>) -> Result<Response<Body>> {
    let mut conn = init_db("./urls.db_3").unwrap();
-    eprintln!("{:?}", req);
    match req.method() {
        &Method::POST => {
-            let b = hyper::body::to_bytes(req)
+            let boundary = req
-                .await
+                .headers()
-                .with_context(|| format!("Failed to stream request body!"))?;
+                .get(CONTENT_TYPE)
+                .and_then(|ct| ct.to_str().ok())
+                .and_then(|ct| multer::parse_boundary(ct).ok());
-            let params = form_urlencoded::parse(b.as_ref())
+            // Send `BAD_REQUEST` status if the content-type is not multipart/form-data.
-                .into_owned()
+            if boundary.is_none() {
-                .collect::<HashMap<String, String>>();
+                let b = hyper::body::to_bytes(req)
+                    .await
+                    .with_context(|| format!("Failed to stream request body!"))?;
-            if let Some(n) = params.get("shorten") {
+                let params = form_urlencoded::parse(b.as_ref())
-                let shortlink = shorten(n, &mut conn)?;
+                    .into_owned()
-                eprintln!("{}", shortlink);
+                    .collect::<HashMap<String, String>>();
-                let res = Response::builder()
-                    .status(StatusCode::OK)
+                if let Some(n) = params.get("shorten") {
-                    .header("content-type", "text/html")
+                    let shortlink = shorten(n, &mut conn)?;
-                    .body(Body::from(shortlink))?;
+                    eprintln!("{}", shortlink);
-                Ok(res)
+                    let res = Response::builder()
+                        .status(StatusCode::OK)
+                        .header("content-type", "text/html")
+                        .body(Body::from(shortlink))?;
+                    return Ok(res);
+                } else {
+                    eprintln!("hello world");
+                    let res = Response::builder()
+                        .status(StatusCode::UNPROCESSABLE_ENTITY)
+                        .body(Body::empty())?;
+                    return Ok(res);
+                }
+            }
+            if let Ok(res) = process_multipart(req.into_body(), boundary.unwrap()).await {
+                return Ok(res);
            } else {
-                eprintln!("hello world");
+                panic!("nani");
-                let res = Response::builder()
-                    .status(StatusCode::UNPROCESSABLE_ENTITY)
-                    .body(Body::empty())?;
-                Ok(res)
            }
        }
        &Method::GET => {
@@ -113,9 +143,7 @@ async fn main() -> Result<()> {
        make_service_fn(|_| async { Ok::<_, hyper::Error>(service_fn(shortner_service)) });
    let server = Server::bind(&addr).serve(service);
    println!("Listening on http://{}", addr);
    server.await.unwrap();
    Ok(())
 }
author	Akshay <[email protected]>	2020-08-23 08:33:21 +0100
committer	Akshay <[email protected]>	2020-08-23 08:33:21 +0100
commit	21f1d776762035012f02be39c96978b0719e0613 (patch)
tree	24fd73624f305281c391825875dcaf941e716090 /src
parent	f36a8fb2eee46cffa87213e070136e5f28194a16 (diff)

diff --git a/src/main.rs b/src/main.rs index cb76d5b..769ed03 100644 --- a/src/main.rs +++ b/src/main.rs
@@ -1,6 +1,8 @@
1	use anyhow::{Context, Result};	1	use anyhow::{Context, Result};
		2	use hyper::header::CONTENT_TYPE;
2	use hyper::service::{make_service_fn, service_fn};	3	use hyper::service::{make_service_fn, service_fn};
3	use hyper::{Body, Method, Request, Response, Server, StatusCode};	4	use hyper::{Body, Method, Request, Response, Server, StatusCode};
		5	use multer::Multipart;
4	use nanoid::nanoid;	6	use nanoid::nanoid;
5	use rusqlite::{params, Connection, OpenFlags, NO_PARAMS};	7	use rusqlite::{params, Connection, OpenFlags, NO_PARAMS};
6	use url::form_urlencoded;	8	use url::form_urlencoded;
@@ -34,34 +36,62 @@ fn get_link<S: AsRef<str>>(url: S, conn: &mut Connection) -> Result<Option<Strin
34	}	36	}
35	}	37	}
36		38
		39	async fn process_multipart(body: Body, boundary: String) -> Result<Response<Body>> {
		40	let mut m = Multipart::new(body, boundary);
		41	if let Some(field) = m.next_field().await? {
		42	let content = field
		43	.text()
		44	.await
		45	.with_context(\|\| format!("Expected field name"))?;
		46	eprintln!("{}", content);
		47	}
		48	Ok(Response::builder()
		49	.status(StatusCode::OK)
		50	.body(Body::empty())?)
		51	}
		52
37	async fn shortner_service(req: Request<Body>) -> Result<Response<Body>> {	53	async fn shortner_service(req: Request<Body>) -> Result<Response<Body>> {
38	let mut conn = init_db("./urls.db_3").unwrap();	54	let mut conn = init_db("./urls.db_3").unwrap();
39	eprintln!("{:?}", req);
40		55
41	match req.method() {	56	match req.method() {
42	&Method::POST => {	57	&Method::POST => {
43	let b = hyper::body::to_bytes(req)	58	let boundary = req
44	.await	59	.headers()
45	.with_context(\|\| format!("Failed to stream request body!"))?;	60	.get(CONTENT_TYPE)
		61	.and_then(\|ct\| ct.to_str().ok())
		62	.and_then(\|ct\| multer::parse_boundary(ct).ok());
46		63
47	let params = form_urlencoded::parse(b.as_ref())	64	// Send `BAD_REQUEST` status if the content-type is not multipart/form-data.
48	.into_owned()	65	if boundary.is_none() {
49	.collect::<HashMap<String, String>>();	66	let b = hyper::body::to_bytes(req)
		67	.await
		68	.with_context(\|\| format!("Failed to stream request body!"))?;
50		69
51	if let Some(n) = params.get("shorten") {	70	let params = form_urlencoded::parse(b.as_ref())
52	let shortlink = shorten(n, &mut conn)?;	71	.into_owned()
53	eprintln!("{}", shortlink);	72	.collect::<HashMap<String, String>>();
54	let res = Response::builder()	73
55	.status(StatusCode::OK)	74	if let Some(n) = params.get("shorten") {
56	.header("content-type", "text/html")	75	let shortlink = shorten(n, &mut conn)?;
57	.body(Body::from(shortlink))?;	76	eprintln!("{}", shortlink);
58	Ok(res)	77	let res = Response::builder()
		78	.status(StatusCode::OK)
		79	.header("content-type", "text/html")
		80	.body(Body::from(shortlink))?;
		81	return Ok(res);
		82	} else {
		83	eprintln!("hello world");
		84	let res = Response::builder()
		85	.status(StatusCode::UNPROCESSABLE_ENTITY)
		86	.body(Body::empty())?;
		87	return Ok(res);
		88	}
		89	}
		90
		91	if let Ok(res) = process_multipart(req.into_body(), boundary.unwrap()).await {
		92	return Ok(res);
59	} else {	93	} else {
60	eprintln!("hello world");	94	panic!("nani");
61	let res = Response::builder()
62	.status(StatusCode::UNPROCESSABLE_ENTITY)
63	.body(Body::empty())?;
64	Ok(res)
65	}	95	}
66	}	96	}
67	&Method::GET => {	97	&Method::GET => {
@@ -113,9 +143,7 @@ async fn main() -> Result<()> {
113	make_service_fn(\|_\| async { Ok::<_, hyper::Error>(service_fn(shortner_service)) });	143	make_service_fn(\|_\| async { Ok::<_, hyper::Error>(service_fn(shortner_service)) });
114		144
115	let server = Server::bind(&addr).serve(service);	145	let server = Server::bind(&addr).serve(service);
116
117	println!("Listening on http://{}", addr);	146	println!("Listening on http://{}", addr);
118
119	server.await.unwrap();	147	server.await.unwrap();
120	Ok(())	148	Ok(())
121	}	149	}