feat: introduce on-disk cache persistance for major nym-api caches

This includes:
- mixnet contract cache
- described nodes cache
- nodes annotations cache (performance)

those changes include taking some code developed for the purposes of #6277

Author: jstuczyn

Cargo.lock

@@ -14,6 +14,7 @@ readme.workspace = true
 futures = { workspace = true }
 thiserror = { workspace = true }
 semver = { workspace = true }
+serde = { workspace = true }
 tokio = { workspace = true, features = ["time"] }
 tracing = { workspace = true }
 url = { workspace = true }

common/ecash-signer-check/Cargo.toml

@@ -3,21 +3,22 @@
 
 use crate::client_check::check_client;
 use futures::stream::{FuturesUnordered, StreamExt};
+use nym_ecash_signer_check_types::status::{SignerResult, Status};
 use nym_network_defaults::NymNetworkDetails;
 use nym_validator_client::QueryHttpRpcNyxdClient;
-use nym_validator_client::nyxd::contract_traits::{DkgQueryClient, PagedDkgQueryClient};
-use std::collections::HashMap;
-use url::Url;
-
-pub use error::SignerCheckError;
-use nym_ecash_signer_check_types::status::{SignerResult, Status};
 use nym_validator_client::ecash::models::EcashSignerStatusResponse;
 use nym_validator_client::models::{
     ChainBlocksStatusResponse, ChainStatusResponse, SignerInformationResponse,
 };
 use nym_validator_client::nyxd::contract_traits::dkg_query_client::{
     ContractVKShare, DealerDetails, Epoch,
 };
+use nym_validator_client::nyxd::contract_traits::{DkgQueryClient, PagedDkgQueryClient};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use url::Url;
+
+pub use error::SignerCheckError;
 
 mod client_check;
 pub mod error;
@@ -31,6 +32,7 @@ pub type TypedSignerResult = SignerResult<
 pub type LocalChainStatus = Status<ChainStatusResponse, ChainBlocksStatusResponse>;
 pub type SigningStatus = Status<SignerInformationResponse, EcashSignerStatusResponse>;
 
+#[derive(Serialize, Deserialize)]
 pub struct SignersTestResult {
     pub threshold: Option<u64>,
     pub results: Vec<TypedSignerResult>,

common/ecash-signer-check/src/lib.rs

@@ -5,11 +5,9 @@ use crate::ecash::api_routes::handlers::ecash_routes;
 use crate::ecash::error::{EcashError, Result};
 use crate::ecash::keys::KeyPairWithEpoch;
 use crate::ecash::state::EcashState;
-use crate::mixnet_contract_cache::cache::MixnetContractCache;
 use crate::network::models::NetworkDetails;
 use crate::node_describe_cache::cache::DescribedNodes;
 use crate::node_status_api::handlers::unstable;
-use crate::node_status_api::NodeStatusCache;
 use crate::status::ApiStatusState;
 use crate::support::caching::cache::SharedCache;
 use crate::support::config;
@@ -1284,8 +1282,8 @@ impl TestFixture {
             ecash_signers_cache: Default::default(),
             address_info_cache: AddressInfoCache::new(Duration::from_secs(42), 1000),
             forced_refresh: ForcedRefresh::new(true),
-            mixnet_contract_cache: MixnetContractCache::new(),
-            node_status_cache: NodeStatusCache::new(),
+            mixnet_contract_cache: SharedCache::new().into(),
+            node_status_cache: SharedCache::new().into(),
             storage,
             described_nodes_cache: SharedCache::<DescribedNodes>::new(),
             network_details: NetworkDetails::new(

nym-api/src/ecash/tests/mod.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use crate::epoch_operations::EpochAdvancer;
-use crate::support::caching::Cache;
+use crate::support::caching::cache::UninitialisedCache;
 use cosmwasm_std::{Decimal, Fraction};
 use nym_api_requests::models::NodeAnnotation;
 use nym_mixnet_contract_common::helpers::IntoBaseDecimal;
@@ -210,10 +210,13 @@ fn determine_per_node_work(
 
 impl EpochAdvancer {
     fn load_performance(
-        status_cache: &Option<RwLockReadGuard<'_, Cache<HashMap<NodeId, NodeAnnotation>>>>,
+        status_cache: &Result<
+            RwLockReadGuard<'_, HashMap<NodeId, NodeAnnotation>>,
+            UninitialisedCache,
+        >,
         node_id: NodeId,
     ) -> NodeWithPerformance {
-        let Some(status_cache) = status_cache.as_ref() else {
+        let Ok(status_cache) = status_cache.as_ref() else {
             return NodeWithPerformance::new_zero(node_id);
         };
 
@@ -239,7 +242,7 @@ impl EpochAdvancer {
         let standby_node_work_factor = nodes_work.standby;
 
         let status_cache = self.status_cache.node_annotations().await;
-        if status_cache.is_none() {
+        if status_cache.is_err() {
             error!("there are no node annotations available");
         };
 

nym-api/src/epoch_operations/helpers.rs

@@ -214,7 +214,7 @@ impl EpochAdvancer {
         #[allow(clippy::unwrap_used)]
         let described_cache = self.described_cache.get().await.unwrap();
 
-        let Some(status_cache) = self.status_cache.node_annotations().await else {
+        let Ok(status_cache) = self.status_cache.node_annotations().await else {
             warn!("there are no node annotations available");
             return Vec::new();
         };

nym-api/src/epoch_operations/rewarded_set_assignment.rs

@@ -7,8 +7,9 @@ use nym_mixnet_contract_common::{
     NymNodeDetails, RewardingParams,
 };
 use nym_topology::CachedEpochRewardedSet;
+use serde::{Deserialize, Serialize};
 
-#[derive(Clone)]
+#[derive(Clone, Serialize, Deserialize)]
 pub(crate) struct ConfigScoreData {
     pub(crate) config_score_params: ConfigScoreParams,
     pub(crate) nym_node_version_history: Vec<HistoricalNymNodeVersionEntry>,
@@ -27,6 +28,7 @@ impl From<ConfigScoreData> for ConfigScoreDataResponse {
     }
 }
 
+#[derive(Serialize, Deserialize)]
 pub(crate) struct MixnetContractCacheData {
     pub(crate) rewarding_denom: String,
 

nym-api/src/mixnet_contract_cache/cache/data.rs

@@ -14,6 +14,8 @@ use nym_mixnet_contract_common::{
 };
 use nym_topology::CachedEpochRewardedSet;
 use nym_validator_client::nyxd::Coin;
+use std::path::Path;
+use std::time::Duration;
 use time::OffsetDateTime;
 use tokio::sync::RwLockReadGuard;
 
@@ -27,10 +29,16 @@ pub struct MixnetContractCache {
     pub(crate) inner: SharedCache<MixnetContractCacheData>,
 }
 
+impl From<SharedCache<MixnetContractCacheData>> for MixnetContractCache {
+    fn from(inner: SharedCache<MixnetContractCacheData>) -> Self {
+        MixnetContractCache { inner }
+    }
+}
+
 impl MixnetContractCache {
-    pub(crate) fn new() -> Self {
+    pub(crate) fn new<P: AsRef<Path>>(store_path: P, max_cache_age: Duration) -> Self {
         MixnetContractCache {
-            inner: SharedCache::new(),
+            inner: SharedCache::new_with_persistent(store_path, max_cache_age, None),
         }
     }
 

nym-api/src/mixnet_contract_cache/cache/mod.rs

@@ -7,6 +7,7 @@ use crate::mixnet_contract_cache::cache::MixnetContractCache;
 use crate::support::caching::refresher::CacheRefresher;
 use crate::support::{config, nyxd};
 use nym_validator_client::nyxd::error::NyxdError;
+use std::path::PathBuf;
 
 pub(crate) mod cache;
 pub(crate) mod handlers;
@@ -15,11 +16,13 @@ pub(crate) fn build_refresher(
     config: &config::MixnetContractCache,
     nym_contract_cache_state: &MixnetContractCache,
     nyxd_client: nyxd::Client,
+    on_disk_file: PathBuf,
 ) -> CacheRefresher<MixnetContractCacheData, NyxdError> {
     CacheRefresher::new_with_initial_value(
         Box::new(MixnetContractDataProvider::new(nyxd_client)),
         config.debug.caching_interval,
         nym_contract_cache_state.inner(),
     )
     .named("mixnet-contract-cache-refresher")
+    .with_persistent_cache(on_disk_file)
 }

nym-api/src/mixnet_contract_cache/mod.rs

@@ -233,7 +233,7 @@ impl PacketPreparer {
     // routes so that they wouldn't be reused
     pub(crate) async fn prepare_test_routes(&self, n: usize) -> Option<Vec<TestRoute>> {
         let descriptions = self.described_cache.get().await.ok()?;
-        let statuses = self.node_status_cache.node_annotations().await?;
+        let statuses = self.node_status_cache.node_annotations().await.ok()?;
 
         let mixing_nym_nodes = descriptions.mixing_nym_nodes();
         // last I checked `gatewaying` wasn't a word : )