Is this is the only possibility to get the content-type header from an Actix-Web request? This has to check if the header is available or if to_str failed...
let req: actix_web::HttpRequest;
let content_type: &str = req
.request()
.headers()
.get(actix_web::http::header::CONTENT_TYPE)
.unwrap()
.to_str()
.unwrap();
Yes, that is the "only" possibility, but it's like that because:
headers().get(key) returns Option.HeaderValue::to_str might fail.actix-web lets you handle those errors individually.
To simplify, you could make a helper function that does not differentiate between the two errors:
fn get_content_type<'a>(req: &'a HttpRequest) -> Option<&'a str> {
req.headers().get("content-type")?.to_str().ok()
}
Full example:
use actix_web::{web, App, HttpRequest, HttpServer, Responder};
fn main() {
HttpServer::new(|| App::new().route("/", web::to(handler)))
.bind("127.0.0.1:8000")
.expect("Cannot bind to port 8000")
.run()
.expect("Unable to run server");
}
fn handler(req: HttpRequest) -> impl Responder {
if let Some(content_type) = get_content_type(&req) {
format!("Got content-type = '{}'", content_type)
} else {
"No content-type header.".to_owned()
}
}
fn get_content_type<'a>(req: &'a HttpRequest) -> Option<&'a str> {
req.headers().get("content-type")?.to_str().ok()
}
Which will give you the results:
$ curl localhost:8000
No content-type header.⏎
$ curl localhost:8000 -H 'content-type: application/json'
Got content-type = 'application/json'⏎
$ curl localhost:8000 -H 'content-type: 💩'
No content-type header.⏎
By the way, you may be interested in guards:
web::route()
.guard(guard::Get())
.guard(guard::Header("content-type", "text/plain"))
.to(handler)
fn get_content_type and not everybody needs to reinvent it. But thanks.
I use the following from a route:
#[get("/auth/login")]
async fn login(request: HttpRequest, session: Session) -> Result<HttpResponse, ApiError> {
let req_headers = request.headers();
let basic_auth_header = req_headers.get("Authorization");
let basic_auth: &str = basic_auth_header.unwrap().to_str().unwrap();
// Keep in mind that calling "unwrap" here could make your application
// panic. The right approach at this point is to evaluate the resulting
// enum variant from `get`'s call
println!("{}", basic_auth); // At this point I have the value of the header as a string
// ...
}
unwrap on any value, Rust your thread will panic if the resulting variant is either Err or None (based on the type returned), and application exits. Using unwrap most of the time is not recommended, the right approach is to handle the variant resulting from the get call.
request and session on the example are injected by the framework automagically.
Allways create a function for that purpose. This is an example for detect if an actix web request is sended by htmx.
use actix_web::HttpRequest;
pub fn is_htmx_request(req: HttpRequest) -> bool {
match req.headers().get("HX-Request") {
Some(header) => match header.to_str() {
Ok(value) => value == "true",
_ => false,
},
_ => false,
}
}
.unwrap().to_str()with.and_then(HeaderValue::to_str)to have one less panic risk.