fix: fixed http stats caching (#42)

Description
---
By mistake SHA3 stats were returned for both RandomX, this is fixed in
this PR.

Motivation and Context
---
Http stats are cached in memory (to avoid too much stress on in memory
share chain).

How Has This Been Tested?
---
- Start P2Pool
- Wait for syncing
- Check stats whether they are the same or not (should not)

What process can a PR reviewer use to test or verify this change?
---
See tests.


Breaking Changes
---

- [x] None
- [ ] Requires data directory on base node to be deleted
- [ ] Requires hard fork
- [ ] Other - Please specify

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sha_p2pool"
-version = "0.1.5-pre.5"
+version = "0.1.5-pre.6"
 edition = "2021"
 
 [dependencies]

src/server/http/stats/cache.rs

@@ -4,6 +4,7 @@
 use crate::server::http::stats::models::Stats;
 use std::sync::Arc;
 use std::time::Duration;
+use tari_core::proof_of_work::PowAlgorithm;
 use tokio::sync::RwLock;
 use tokio::time::Instant;
 
@@ -21,7 +22,8 @@ impl CachedStats {
 
 pub struct StatsCache {
     ttl: Duration,
-    stats: Arc<RwLock<Option<CachedStats>>>,
+    stats_sha3x: Arc<RwLock<Option<CachedStats>>>,
+    stats_randomx: Arc<RwLock<Option<CachedStats>>>,
 }
 
 impl Default for StatsCache {
@@ -34,12 +36,17 @@ impl StatsCache {
     pub fn new(ttl: Duration) -> Self {
         Self {
             ttl,
-            stats: Arc::new(RwLock::new(None)),
+            stats_sha3x: Arc::new(RwLock::new(None)),
+            stats_randomx: Arc::new(RwLock::new(None)),
         }
     }
 
-    pub async fn update(&self, stats: Stats) {
-        let mut stats_lock = self.stats.write().await;
+    pub async fn update(&self, stats: Stats, pow_algo: PowAlgorithm) {
+        let stats_lock = match pow_algo {
+            PowAlgorithm::RandomX => self.stats_randomx.clone(),
+            PowAlgorithm::Sha3x => self.stats_sha3x.clone(),
+        };
+        let mut stats_lock = stats_lock.write().await;
         match &mut *stats_lock {
             Some(curr_stats) => {
                 curr_stats.stats = stats;
@@ -51,12 +58,16 @@ impl StatsCache {
         }
     }
 
-    pub async fn stats(&self) -> Option<Stats> {
-        let lock = self.stats.read().await;
+    pub async fn stats(&self, pow_algo: PowAlgorithm) -> Option<Stats> {
+        let stats_lock = match pow_algo {
+            PowAlgorithm::RandomX => self.stats_randomx.clone(),
+            PowAlgorithm::Sha3x => self.stats_sha3x.clone(),
+        };
+        let lock = stats_lock.read().await;
         let last_update = lock.as_ref()?.last_update;
         if lock.is_some() && Instant::now().duration_since(last_update) > self.ttl {
             drop(lock);
-            let mut lock = self.stats.write().await;
+            let mut lock = stats_lock.write().await;
             *lock = None;
             return None;
         }

src/server/http/stats/handlers.rs

@@ -43,7 +43,7 @@ pub async fn handle_get_stats(State(state): State<AppState>) -> Result<Json<Hash
 async fn get_stats(state: AppState, algo: PowAlgorithm) -> Result<Stats, StatusCode> {
     // return from cache if possible
     let stats_cache = state.stats_cache.clone();
-    if let Some(stats) = stats_cache.stats().await {
+    if let Some(stats) = stats_cache.stats(algo).await {
         return Ok(stats);
     }
 
@@ -171,7 +171,7 @@ async fn get_stats(state: AppState, algo: PowAlgorithm) -> Result<Stats, StatusC
         tribe: TribeDetails::new(state.tribe.to_string(), state.tribe.formatted()),
     };
 
-    stats_cache.update(result.clone()).await;
+    stats_cache.update(result.clone(), algo).await;
 
     Ok(result)
 }