Would using RwLock instead of Mutex make sense? about cached HOT 20 OPEN

async fn get_new_token() -> Result<VapToken> {
    let req_body = format!(
        r#"
                {{
                    "strategy": "local",
                    "email": "{email}",
                    "password": "{password}"
                }}
                "#,
        email = VAP_AUTH.svc_acc_usr,
        password = VAP_AUTH.svc_acc_pwd,
    );

    let mut headers = HeaderMap::new();
    headers.insert("Content-Type", HeaderValue::from_str("application/json")?);

    trace!("/vapapi/authentication/v1 body {}", req_body);

    let resp = HTTP_CLIENT
        .post(&format!(
            "{}/vapapi/authentication/v1",
            VAP_AUTH.vap_base_url
        ))
        .body(req_body)
        .headers(headers)
        .send()
        .await?;

    let status = resp.status();
    debug!("status: {}", status);

    let resp = resp.text().await?; // extract body as string

    eval_status_code_reqwest!(
        status,
        reqwest::StatusCode::CREATED,
        resp,
        "error when calling  get_new_token"
    );

    Ok(serde_json::from_str(&resp)?)
}

/// Returns VAP bearer token as a string
/// Result is cached/memoized for 60*60*23 seconds, i.e. 23 hours
/// which leaves one hour safety buffer (VAP token validity is 24 hours)
/// cache only Ok values, not errors
#[cached(size = 1, time = 82800, result = true)]
pub async fn get_token() -> Result<String> {
    let new_token = get_new_token().await?;
    Ok(new_token.access_token)
}

lazy_static! {
    static ref CACHE: Arc<async_rwlock::RwLock<Vec<i64, String>>> = Arc::new(RwLock::new(Vec::with_capacity(1)));
}

async fn get_token() -> Result<String> {
    {
        let token = CACHE.read().await.get(0);
        if let Some((created_ts, token)) = token {
            if (now - created_ts) < 82800 { return Ok(token) }
        }
    }
    let mut store = CACHE.write().await;
    let already_set = store.get(0).map(|(created_ts, _)| (now - created_ts) < 82800).unwrap_or(false);
    if already_set {
        Ok(store[0].1.clone())
    else {
        let token = get_new_token().await?;
        store.clear();
        store.push((now, token.clone()));
        Ok(token)
    }
}

lazy_static! {
    static ref CACHE: Arc<async_rwlock::RwLock<Vec<(u128, String)>>> =
        Arc::new(RwLock::new(Vec::with_capacity(1)));
}

fn time_now() -> u128 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_millis()
}

async fn get_token() -> Result<String> {
    {
        let token = CACHE.read().await;
        if let Some((created_ts, token)) = token.get(0) {
            if (time_now() - *created_ts) < 82800 {
                return Ok(String::from(token));
            }
        }
    }
    let mut store = CACHE.write().await;
    let already_set = store
        .get(0)
        .map(|(created_ts, _)| (time_now() - created_ts) < 82800)
        .unwrap_or(false);
    if already_set {
        return Ok(store[0].1.clone());
    } else {
        let token = get_new_token().await?;
        store.clear();
        store.push((time_now(), token.access_token.to_owned()));
        Ok(token.access_token)
    }
}

async fn get_token() -> Result<String> {
    {
        let token = CACHE.read().await;
        if let Some((created_ts, token)) = token.get(0) {
            if (time_now() - *created_ts) < 82800 {
                return Ok(String::from(token));
            }
        }
    }
    let mut store = CACHE.write().await;
    let token = get_new_token().await?;
    store.clear();
    store.push((time_now(), token.access_token.to_owned()));
    Ok(token.access_token)
}

    static ref CACHE: Arc<tokio::sync::RwLock<Vec<(u128, String)>>> =
        Arc::new(tokio::sync::RwLock::new(Vec::with_capacity(1)));

[dependencies]
tokio = { version = "1.7.1", default-features = false, features = ["macros", "time", "rt-multi-thread", "signal", "fs", "rt"] }
cached = "0.26.0"

[dev-dependencies]
criterion = { version = "0.3.5", features = ["async_tokio", "html_reports"] }

[[bench]]
name = "benchmarks"
harness = false

use criterion::{criterion_group, criterion_main, Criterion};
use cached::proc_macro::once;
use lazy_static::lazy_static;
use std::sync::Arc;
use std::time::{SystemTime, UNIX_EPOCH};
use va_voice_gateway_rs::errors::Result;
use va_voice_gateway_rs::nlp::vap::{VapToken, VapTokenAuth, VapTokenUser};

lazy_static! {
    static ref CACHE: Arc<tokio::sync::RwLock<Vec<(u128, String)>>> =
        Arc::new(tokio::sync::RwLock::new(Vec::with_capacity(1)));
}

/// dummy function for getting new token. instead of doing respective http call
/// it simply returns hardcoded value.
async fn get_new_token() -> Result<VapToken> {
    Ok(VapToken {
        access_token: "123456".to_owned(),
        authentication: VapTokenAuth {
            strategy: "local".to_owned(),
        },
        user: VapTokenUser {
            user_id: "usr123".to_owned(),
            email: "[email protected]".to_owned(),
            description: "some desc".to_owned(),
            allowed_services: vec!["SvcA".to_owned(), "SvcB".to_owned()],
        },
    })
}

fn time_now() -> u128 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis()
}

#[once(time = 82800, result = true, sync_writes = true)]
async fn get_token() -> Result<String> {
    let new_token = get_new_token().await?;
    Ok(new_token.access_token)
}

async fn get_token_manual() -> Result<String> {
    {
        let token = CACHE.read().await;
        if let Some((created_ts, token)) = token.get(0) {
            if (time_now() - *created_ts) < 82800 {
                return Ok(String::from(token));
            }
        }
    }
    let mut store = CACHE.write().await;
    // this is needed to prevent multiple writers from getting the lock
    // one by one and retrieving token multiple times
    let already_set = store
        .get(0)
        .map(|(created_ts, _)| (time_now() - created_ts) < 82800)
        .unwrap_or(false);
    if already_set {
        Ok(store[0].1.clone())
    } else {
        let token = get_new_token().await?;
        store.clear();
        store.push((time_now(), token.access_token.to_owned()));
        Ok(token.access_token)
    }
}

pub fn benchmark_suite(c: &mut Criterion) {
    // create the tokio runtime to be used for the benchmarks
    let rt = tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()
        .unwrap();

    c.bench_function("get_token", |b| {
        b.to_async(&rt).iter(|| async {
            get_token().await.unwrap();
        })
    });

    c.bench_function("get_token_manual", |b| {
        b.to_async(&rt).iter(|| async {
            get_token_manual().await.unwrap();
        })
    });
}

criterion_group!(benches, benchmark_suite);
criterion_main!(benches);