How to create global variables with State?

[779505388]

How to create global variables with State?

[robertwayne]

If you mean data you can access with &State<T>, this is a rough example:

// main.rs
use rocket::State;
use std::sync::Mutex;

struct Counter {
    pub inner: Mutex<u32>,
}

impl Counter {
    pub fn new() -> Self {
        Counter {
            inner: Mutex::new(0),
        }
    }
}

#[get("/")]
async fn index(counter: &State<Counter>) -> String {
    let mut counter = counter.inner.lock().unwrap();
    *counter += 1;

    format!("{}", counter)
}

#[launch]
fn rocket() -> _ {
    rocket::build()
        .manage(Counter::new())
        .mount("/", routes![index])
}

With that code, anytime someone visits the index, the counter would increase by 1.

By using the .manage() method on your Rocket builder, you make your struct (or whatever) available anywhere State can be retrieved (eg. request guards, etc).

Note that State is Send + Sync, so if you want mutable access to data, you have to use interior mutability (eg. Mutex, RwLock).

[779505388]

``I changed the inner type to String

#[derive(Debug, Clone)]
pub struct BlogSet {
    name: Mutex<String>,
}

But an error：

the trait bound `std::sync::Mutex<std::string::String>: Clone` is not satisfied
the trait `Clone` is not implemented for `std::sync::Mutex<std::string::String>`

How can I solve this problem? Thank you!

[SergioBenitez]

Remove the Clone derive. Alternatively, if you really want/need the struct to be Clone, use an Arc, as in Arc<Mutex<String>>.

[CSharper63]

Hello @SergioBenitez ,
Additional question about state use case. As I understood it is a thread-safe area where I can store data such as config and db conn pool. My question is: is it possible to access this managed state anywhere in code (out of route/handler for example). This would imply to access something like a rocket context ?
To understand the case:
For example I have a struct ServerConfig with my connection and some env keys. The goal would be to access theses env keys everywhere is needed like a secret encryption key or something like that. Or the best way is the create a static struct with my env keys and a mutex to protect the connection access ?