Method background_refresh

plugins/currencyrate-plugin/src/oracle.rs:433–536

(&self, currency: &str)

    }

    fn background_refresh(&self, currency: &str) {
        let inner = self.inner.clone();
        let client = self.client.clone();
        let currency = currency.to_owned();
        tokio::spawn(async move {
            tokio::time::sleep(SOURCE_TIMEOUT_SECS * 5).await;
            loop {
                let mut inner = inner.lock().await;
                let now = Instant::now();
                inner.reset_backoff_if_needed(now);
                let available_sources: Vec<String> = inner
                    .sources
                    .iter()
                    .filter(|(_, source_health)| source_health.backoff_until < now)
                    .map(|(name, _)| name)
                    .cloned()
                    .collect();

                let prices = inner
                    .currencies
                    .get(&currency)
                    .map(|currency_cache| &currency_cache.prices);

                let mut sources_by_staleness: Vec<(String, Option<Instant>)> = available_sources
                    .into_iter()
                    .map(|name| {
                        let last_fetch = prices
                            .and_then(|prices| prices.get(&name))
                            .map(|price_cache| price_cache.timestamp);
                        (name, last_fetch)
                    })
                    .collect();

                sources_by_staleness.sort_by_key(|(_, s)| *s);

                let stale_cutoff = now - SERVE_TTL + 2 * SOURCE_TIMEOUT_SECS;
                if sources_by_staleness
                    .last()
                    .and_then(|(_, timestamp)| *timestamp)
                    .is_some_and(|timestamp| timestamp > stale_cutoff)
                {
                    sources_by_staleness.clear();
                }

                log::trace!(
                    "sources_by_staleness: {}",
                    sources_by_staleness
                        .iter()
                        .map(|(n, p)| format!(
                            "{n}:{}",
                            p.map(|f| f.elapsed().as_secs()).unwrap_or(0)
                        ))
                        .collect::<Vec<String>>()
                        .join(", ")
                );

                for (name, _) in sources_by_staleness {
                    let source_health = inner.sources.get_mut(&name).unwrap();