graph, node, store: Remove ttl_max_contracts from clear_stale_call_cache

The ttl_max_contracts parameter limited how many contracts got processed
per invocation. With the upcoming switch to a more efficient delete
strategy that doesn't iterate by contract, this parameter no longer
maps to anything meaningful. Remove it from the trait, CLI, and all
implementations.

Author: lutter

graph/src/blockchain/mock.rs

@@ -592,11 +592,7 @@ impl ChainStore for MockChainStore {
     async fn clear_call_cache(&self, _from: BlockNumber, _to: BlockNumber) -> Result<(), Error> {
         unimplemented!()
     }
-    async fn clear_stale_call_cache(
-        &self,
-        _ttl_days: usize,
-        _ttl_max_contracts: Option<usize>,
-    ) -> Result<(), Error> {
+    async fn clear_stale_call_cache(&self, _ttl_days: usize) -> Result<(), Error> {
         unimplemented!()
     }
     async fn chain_identifier(&self) -> Result<ChainIdentifier, Error> {

graph/src/components/store/traits.rs

@@ -658,11 +658,7 @@ pub trait ChainStore: ChainHeadStore {
     async fn clear_call_cache(&self, from: BlockNumber, to: BlockNumber) -> Result<(), Error>;
 
     /// Clears stale call cache entries for the given TTL in days.
-    async fn clear_stale_call_cache(
-        &self,
-        ttl_days: usize,
-        ttl_max_contracts: Option<usize>,
-    ) -> Result<(), Error>;
+    async fn clear_stale_call_cache(&self, ttl_days: usize) -> Result<(), Error>;
 
     /// Return the chain identifier for this store.
     async fn chain_identifier(&self) -> Result<ChainIdentifier, Error>;

node/src/bin/manager.rs

@@ -621,9 +621,6 @@ pub enum CallCacheCommand {
         /// Remove the cache for contracts that have not been accessed in the last <TTL_DAYS> days
         #[clap(long, conflicts_with_all = &["from", "to", "remove-entire-cache"], value_parser = clap::value_parser!(u32).range(1..))]
         ttl_days: Option<usize>,
-        /// Limits the number of contracts to consider for cache removal when using --ttl_days
-        #[clap(long, conflicts_with_all = &["remove-entire-cache", "to", "from"], requires = "ttl_days", value_parser = clap::value_parser!(u64).range(1..))]
-        ttl_max_contracts: Option<usize>,
         /// Starting block number
         #[clap(long, short, conflicts_with = "remove-entire-cache", requires = "to")]
         from: Option<i32>,
@@ -1549,14 +1546,12 @@ async fn main() -> anyhow::Result<()> {
                             to,
                             remove_entire_cache,
                             ttl_days,
-                            ttl_max_contracts,
                         } => {
                             let chain_store = ctx.chain_store(&chain_name).await?;
                             if let Some(ttl_days) = ttl_days {
                                 return commands::chain::clear_stale_call_cache(
                                     chain_store,
                                     ttl_days,
-                                    ttl_max_contracts,
                                 )
                                 .await;
                             }

node/src/manager/commands/chain.rs

@@ -84,15 +84,12 @@ pub async fn clear_call_cache(
 pub async fn clear_stale_call_cache(
     chain_store: Arc<ChainStore>,
     ttl_days: usize,
-    ttl_max_contracts: Option<usize>,
 ) -> Result<(), Error> {
     println!(
         "Removing stale entries from the call cache for `{}`",
         chain_store.chain
     );
-    chain_store
-        .clear_stale_call_cache(ttl_days, ttl_max_contracts)
-        .await?;
+    chain_store.clear_stale_call_cache(ttl_days).await?;
     Ok(())
 }
 

store/postgres/src/chain_store.rs

@@ -3276,11 +3276,7 @@ impl ChainStoreTrait for ChainStore {
         Ok(())
     }
 
-    async fn clear_stale_call_cache(
-        &self,
-        ttl_days: usize,
-        ttl_max_contracts: Option<usize>,
-    ) -> Result<(), Error> {
+    async fn clear_stale_call_cache(&self, ttl_days: usize) -> Result<(), Error> {
         let conn = &mut self.pool.get_permitted().await?;
 
         self.storage
@@ -3289,35 +3285,13 @@ impl ChainStoreTrait for ChainStore {
 
         let mut total_calls: usize = 0;
         let mut total_contracts: usize = 0;
-        // We process contracts in batches to avoid loading too many
-        // entries into memory at once. Each contract can have many
-        // calls, so we delete calls in adaptive batches that
-        // self-tune based on query duration.
         let contracts_batch_size: usize = ENV_VARS.store.stale_call_cache_contracts_batch_size;
         let mut batch_size = AdaptiveBatchSize::with_size(100);
 
-        // Limits the number of contracts to process if ttl_max_contracts is set.
-        // Used also to adjust the final batch size, so we don't process more
-        // contracts than the set limit.
-        let remaining_contracts = |processed: usize| -> Option<usize> {
-            ttl_max_contracts.map(|limit| limit.saturating_sub(processed))
-        };
-
         loop {
-            if let Some(0) = remaining_contracts(total_contracts) {
-                info!(self.logger,
-                    "Finished cleaning call cache: deleted {} entries for {} contracts (limit reached)",
-                    total_calls, total_contracts);
-                break;
-            }
-
-            let batch_limit = remaining_contracts(total_contracts)
-                .map(|left| left.min(contracts_batch_size))
-                .unwrap_or(contracts_batch_size);
-
             let stale_contracts = self
                 .storage
-                .stale_contracts(conn, batch_limit, ttl_days)
+                .stale_contracts(conn, contracts_batch_size, ttl_days)
                 .await?;
 
             if stale_contracts.is_empty() {

store/test-store/tests/postgres/chain_head.rs

@@ -636,7 +636,7 @@ fn test_clear_stale_call_cache() {
             .await
             .unwrap();
         }
-        let result = chain_store.clear_stale_call_cache(7, None).await;
+        let result = chain_store.clear_stale_call_cache(7).await;
         assert!(result.is_ok());
 
         // Confirm the call cache entry was removed