An example using Redis would be nice

[jsoneaday]

Doesn't have to be massive just a jump start would be nice.

[davidpdrsn]

It would be very similar to https://github.com/tokio-rs/axum/blob/main/examples/tokio-postgres/src/main.rs

[HosMercury]

note that redis conn is mut
so there is no easier way to share between threads through app_state

[davidpdrsn]

Don't share a single connection. Share https://docs.rs/redis/0.23.0/redis/aio/struct.ConnectionManager.html instead.

[smentek]

Is it not redis::aio::MultiplexedConnection now?

[maojinhua]

When using Redis, I encountered a timeout issue of ten seconds for connection requests, as shown in the code below. How can I resolve this? I am looking forward to the answer. Thank you.

// appstate Struct
pub struct AppState { pub conn: DatabaseConnection, pub conf: config::Conf, pub uploader: Uploader, pub redis_client: RedisClient, }

// use is_exist func
let is_repeat = is_exist(&state.redis_client, &key).await;

// the result is only print is_exist start get_async_connection,not print end get_async_connection.

`use redis::{AsyncCommands, ExistenceCheck, SetExpiry, SetOptions};

pub async fn is_exist(redis_client: &redis::Client, key: &str) -> bool {

tracing::info!("is_exist start get_async_connection key={}", key);
let mut redis_con = redis_client
    .get_async_connection()
    .await
    .expect(format!("get_async_connection failed").as_str());
tracing::info!("end get_async_connection key={}", key);

tracing::info!("is_exist start set_options key={}", key);
let opts = SetOptions::default()
    .conditional_set(ExistenceCheck::NX)
    .get(true)
    .with_expiration(SetExpiry::EX(600));
let is_exist: bool = redis_con
    .set_options(&key, 1, opts)
    .await
    .expect(format!("set gen_webhook_job_status_key {} failed", key).as_str());
tracing::info!("is_exist end set_options key={}", key);

return is_exist;

}`

[davidpdrsn]

That feels more like a redis question than an axum question. Try asking somewhere else maybe. I don't have much experience with redis in rust.

[tversteeg]

@drbh implemented this here: https://github.com/tokio-rs/axum/blob/main/examples/tokio-redis/src/main.rs

[zhaoyii]

Using ConnectionManager, share ConnectionManager through clone, for example:

use redis::aio::ConnectionManager;
pub struct AppState {
    pub conn: ConnectionManager,
}

pub async fn foobar(State(state): State<Arc<AppState>>) {
    let mut conn= state.conn.clone();
    redis::cmd("SET").arg(&["key2", "bar"]).exec_async(&mut conn).await.unwrap();
    pipe.query_async(&mut conn).await.unwrap();
}

To use the pipe.query_async function, state.conn.clone() is used to clone ConnectionManager. Inside ConnectionManager is an Arc<T>, which can be safely shared between asynchronous threads through clone.