Is State cloned for each request?

[soasada]

Hi, I'm a little bit confused with clone and Arc when using with_state function.

I have the following AppState:

use tokio::sync::mpsc;

#[derive(Clone)]
pub struct ActorHandle {
    sender: mpsc::Sender<ActorMessage>,
}

impl ActorHandle {
  pub async fn send_msg(&self, msg: ActorMessage) {
    self.sender.send(msg).await;
  }
}

#[derive(Clone)]
pub struct AppState {
    pub actor_handle: ActorHandle,
}

When I create my axum router I create a regular AppState without Arc:

use tokio::sync::mpsc;

let (sender, receiver) = mpsc::channel(32);

let app_state = AppState {
        actor_handle: ActorHandle { sender }
};

let router = Router::new()
  .route("/foo", post(foo))
  .with_state(app_state);

Then I use it in the handler as a regular variable:

pub async fn foo(State(state): State<AppState>) -> impl IntoResponse {
  // msg creation omitted for brevity 
  state.actor_handle.send_msg(msg).await; // should I use state.clone() and then use the variable "actor_handle"?
}

Is this legal? do I need to clone or add Arc type to my state if this is my use case?

[davidpdrsn]

Yes the state is cloned for each request. Otherwise you wouldn't be able to extract an owned state.

[davidpdrsn]

No. Pools are often arcs internally.

[thomasmost]

Got it! Thank you so much

[musjj]

If you have substates like:

struct Foo;
struct Bar;

struct AppState {
    foo: Foo,
    bar: Bar,
}

impl FromRef<AppState> for Foo {
    fn from_ref(input: &AppState) -> Self {
        input.foo.clone()
    }
}

fn my_route(
    State(foo): State<Foo>,
) {
    todo!()
}

Is AppState cloned on every request too? Or just Foo?

[mladedav]

It's cloned on every request. Or rather whatever you used in the with_state call for the give route that the request matched will be used.

[musjj]

So with my example, if you do:

let router = Router::new()
    .route("/my_route", my_route)
    .with_state(AppState { .. })

AppState will be cloned, then Foo will be cloned again afterwards?