Example for registering data is incomplete and fails in the obvious use case

[Lindenk]

Here's the example for adding application data to the server:

use std::sync::Mutex;
use actix_web::{web, App};

struct MyData {
    counter: usize,
}

/// Use `Data<T>` extractor to access data in handler.
fn index(data: web::Data<Mutex<MyData>>) {
    let mut data = data.lock().unwrap();
    data.counter += 1;
}

fn main() {
    let data = web::Data::new(Mutex::new(MyData{ counter: 0 }));

    let app = App::new()
        // Store `MyData` in application storage.
        .register_data(data.clone())
        .service(
            web::resource("/index.html").route(
                web::get().to(index)));
}

And here is the example for running a server:

fn main() {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(index))
            .route("/again", web::get().to(index2))
    })
    .bind("127.0.0.1:8088")
    .unwrap()
    .run()
    .unwrap();
}

The first example does not include HttpServer, doesn't bind to a port, and doesn't serve an application. Attempting to wrap the App in an HttpServer means web::Data<T> must be Send. Apparently, it also forces T in web::Data<Arc<Mutex<T>>> to also be Send instead of using the wrapped value.

Here's a direct example of the problem:

use std::sync::{Arc, Mutex};
use std::rc::Rc;
use actix_web::{web, App, HttpServer};

fn main() {
  let foo = web::Data::new(Arc::new(Mutex::new(Rc::new(0))));
  
  HttpServer::new( || {
    App::new()
      .register_data(foo.clone())
  })
    .bind("0.0.0.0:8080").unwrap()
    .run().unwrap();
}

[ninjasource]

Same issue here, solution below. This applies to the Shared Mutable State section under Basics | Application in the docs. It is not clear where the user should put the app data.

The example should be something like this (note the "move" when creating the HttpServer):

fn main() {
    let data = web::Data::new(AppState {
        counter: Mutex::new(0),
    });

    HttpServer::new(move || {
        App::new()
            .register_data(data.clone()) // <- register the created data
            .route("/", web::get().to(index))
    })
        .bind("127.0.0.1:1337")
        .unwrap()
        .run()
        .unwrap();
}

Note to reader: See Extractors | Async Data Access section for an explanation about the dangers of using a mutex in an async handler. Your application becomes single threaded while the mutex is held and awaiting inside one of these locks is particularly bad because it can lead to deadlocks.

[leizzer]

@Lindenk where is that example from?
did you check the state example?
https://github.com/actix/examples/tree/master/state

Actix-web went through a lot of changes, so some examples could be outdated

[ninjasource]

Thanks @Lindenk, I figured it out from the state example. This is indeed a case of outdated docs. See
https://actix.rs/docs/application/
In the "Shared Mutable State" section and after the text "and register the data in an App:" the code is incomplete as an example.

[leizzer]

I just filled a ticket regarding this documentation issue actix/actix-website#109
Gonna close this issue now