actix-web | An archive of the old actix-web repository

I think you mix the Authorization with CORS. The CORS doesn't mean you are unable to direct access the page, it means if you are accessing site A, and in site A, some javascript is trying to access some resources on site B, the brower will decide whether you can access Site B base on the CORS settings.

In your case, you are allowing the "https://www.rust-lang.org" to access your site (http://127.0.0.1/index.html). This means if somehow the "https://www.rust-lang.org" want to have a javascript code to access your local site, the brower will allow it to do so. But in practice, rust-lang.org will almost never try to access your localhost, so this is just purely an code example of actix cors.

I think what you are looking for is a Authorization middware, the CORS doesn't fit your purpose.

Both types have the same traits but with different fields in it.

Yes but as Ivan C noted that's not what impl Trait does. impl Trait is essentially a placeholder for a normal type which implements the trait (it also makes the return type opaque which lets you e.g. return private types from pub functions).

Does it possible to return two types ?

Technically no, a Rust function can only return values of one type, however there are usually ways around this. One is to return a dynamically dispatched object via Box. This is slightly less efficient, but if the trait is object-safe (note: I've no idea if Responder is) then it lets you leverage trait objects to kinda-sorta return different types from the same function.

An alternative is that the one trait is basically just an intermediate step and ends up converting to a single concrete type at the end. While you'd usually return something implementing the trait for convenience you can… take the final step yourself "by hand".

In Actix, I expect that's HttpResponse, which you can either build "by hand" or using Responder::respond_to.

You can use serde_json::value::Value

If you do not have a proxy in front of the service, it should be retrievable from the request peer_addr().

Otherwise, you can retrieve the request connection_info(), and from there, the realip_remote_addr().

Example:

Using https://actix.rs/docs/extractors/.

Change:

1. async fn post(mut payload: Multipart) → async fn post(path: web::Path, mut payload: Multipart)
2. .route("/", web::post().to(post)) → .route("/{id}", web::post().to(post))
3. →

You have incompatible versions of actix crates. You can either downgrade actix-rt to 1, or upgrade to beta versions like:

To make this work, we need to change the code such that the stream has ownership of the connection it is reading from, and due to how bb8 is written, you also need ownership of a handle to the pool. The best way to do this is to use the async-stream crate.

I believe something like this should do it:

I'm hoping there is a way to ... make a dependency conditional

See Specifying Dependencies in the Cargo Book for configuring conditional dependencies in Cargo.toml. In your case you would want something like: