mirror of
https://github.com/actix/examples
synced 2025-02-23 09:43:03 +01:00
99 lines
2.9 KiB
Rust
99 lines
2.9 KiB
Rust
// This is a contrived example intended to illustrate actix-web features.
|
|
// *Imagine* that you have a process that involves 3 steps. The steps here
|
|
// are dumb in that they do nothing other than call an
|
|
// httpbin endpoint that returns the json that was posted to it. The intent
|
|
// here is to illustrate how to chain these steps together as futures and return
|
|
// a final result in a response.
|
|
//
|
|
// Actix-web features illustrated here include:
|
|
// 1. handling json input param
|
|
// 2. validating user-submitted parameters using the 'validator' crate
|
|
// 2. actix-web client features:
|
|
// - POSTing json body
|
|
// 3. chaining futures into a single response used by an async endpoint
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use std::collections::HashMap;
|
|
use std::io;
|
|
|
|
use actix_web::{
|
|
client::Client,
|
|
error::ErrorBadRequest,
|
|
web::{self, BytesMut},
|
|
App, Error, HttpResponse, HttpServer,
|
|
};
|
|
use futures::StreamExt;
|
|
use validator::Validate;
|
|
use validator_derive::Validate;
|
|
|
|
#[derive(Debug, Validate, Deserialize, Serialize)]
|
|
struct SomeData {
|
|
#[validate(length(min = 1, max = 1000000))]
|
|
id: String,
|
|
#[validate(length(min = 1, max = 100))]
|
|
name: String,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct HttpBinResponse {
|
|
args: HashMap<String, String>,
|
|
data: String,
|
|
files: HashMap<String, String>,
|
|
form: HashMap<String, String>,
|
|
headers: HashMap<String, String>,
|
|
json: SomeData,
|
|
origin: String,
|
|
url: String,
|
|
}
|
|
|
|
/// validate data, post json to httpbin, get it back in the response body, return deserialized
|
|
async fn step_x(data: SomeData, client: &Client) -> Result<SomeData, Error> {
|
|
// validate data
|
|
data.validate().map_err(ErrorBadRequest)?;
|
|
|
|
let mut res = client
|
|
.post("https://httpbin.org/post")
|
|
.send_json(&data)
|
|
.await
|
|
.map_err(Error::from)?; // <- convert SendRequestError to an Error
|
|
|
|
let mut body = BytesMut::new();
|
|
while let Some(chunk) = res.next().await {
|
|
body.extend_from_slice(&chunk?);
|
|
}
|
|
|
|
let body: HttpBinResponse = serde_json::from_slice(&body).unwrap();
|
|
Ok(body.json)
|
|
}
|
|
|
|
async fn create_something(
|
|
some_data: web::Json<SomeData>,
|
|
client: web::Data<Client>,
|
|
) -> Result<HttpResponse, Error> {
|
|
let some_data_2 = step_x(some_data.into_inner(), &client).await?;
|
|
let some_data_3 = step_x(some_data_2, &client).await?;
|
|
let d = step_x(some_data_3, &client).await?;
|
|
|
|
Ok(HttpResponse::Ok()
|
|
.content_type("application/json")
|
|
.body(serde_json::to_string(&d).unwrap()))
|
|
}
|
|
|
|
#[actix_web::main]
|
|
async fn main() -> io::Result<()> {
|
|
std::env::set_var("RUST_LOG", "actix_web=info");
|
|
env_logger::init();
|
|
let endpoint = "127.0.0.1:8080";
|
|
|
|
println!("Starting server at: {:?}", endpoint);
|
|
HttpServer::new(|| {
|
|
App::new()
|
|
.data(Client::default())
|
|
.service(web::resource("/something").route(web::post().to(create_something)))
|
|
})
|
|
.bind(endpoint)?
|
|
.run()
|
|
.await
|
|
}
|