Backport to branch(3.16) : Disable negative cache for table metadata (#3234)

Co-authored-by: Toshihiro Suzuki <[email protected]>

Author: feeblefakie

build.gradle

@@ -41,6 +41,7 @@ subprojects {
         mariadDbDriverVersion = '3.5.3'
         picocliVersion = '4.7.7'
         commonsTextVersion = '1.13.1'
+        caffeineVersion = '2.9.3'
         junitVersion = '5.11.4'
         commonsLangVersion = '3.17.0'
         assertjVersion = '3.27.3'

core/build.gradle

@@ -174,6 +174,7 @@ dependencies {
         exclude group: 'org.slf4j', module: 'slf4j-api'
     }
     implementation "org.apache.commons:commons-text:${commonsTextVersion}"
+    implementation "com.github.ben-manes.caffeine:caffeine:${caffeineVersion}"
     testImplementation "org.junit.jupiter:junit-jupiter-api:${junitVersion}"
     testImplementation "org.junit.jupiter:junit-jupiter-params:${junitVersion}"
     testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junitVersion}"

core/src/main/java/com/scalar/db/common/TableMetadataManager.java

@@ -1,48 +1,37 @@
 package com.scalar.db.common;
 
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.benmanes.caffeine.cache.LoadingCache;
 import com.scalar.db.api.Admin;
 import com.scalar.db.api.Operation;
 import com.scalar.db.api.TableMetadata;
 import com.scalar.db.exception.storage.ExecutionException;
 import com.scalar.db.util.ScalarDbUtils;
 import com.scalar.db.util.ThrowableFunction;
 import java.util.Objects;
-import java.util.Optional;
+import java.util.concurrent.CompletionException;
 import java.util.concurrent.TimeUnit;
-import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
 
 /** A class that manages and caches table metadata */
 @ThreadSafe
 public class TableMetadataManager {
 
-  private final LoadingCache<TableKey, Optional<TableMetadata>> tableMetadataCache;
+  private final LoadingCache<TableKey, TableMetadata> tableMetadataCache;
 
   public TableMetadataManager(Admin admin, long cacheExpirationTimeSecs) {
-    this(
-        key -> Optional.ofNullable(admin.getTableMetadata(key.namespace, key.table)),
-        cacheExpirationTimeSecs);
+    this(key -> admin.getTableMetadata(key.namespace, key.table), cacheExpirationTimeSecs);
   }
 
   public TableMetadataManager(
-      ThrowableFunction<TableKey, Optional<TableMetadata>, Exception> getTableMetadataFunc,
+      ThrowableFunction<TableKey, TableMetadata, Exception> getTableMetadataFunc,
       long cacheExpirationTimeSecs) {
-    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder();
+    Caffeine<Object, Object> builder = Caffeine.newBuilder();
     if (cacheExpirationTimeSecs >= 0) {
       builder.expireAfterWrite(cacheExpirationTimeSecs, TimeUnit.SECONDS);
     }
-    tableMetadataCache =
-        builder.build(
-            new CacheLoader<TableKey, Optional<TableMetadata>>() {
-              @Nonnull
-              @Override
-              public Optional<TableMetadata> load(@Nonnull TableKey key) throws Exception {
-                return getTableMetadataFunc.apply(key);
-              }
-            });
+    tableMetadataCache = builder.build(getTableMetadataFunc::apply);
   }
 
   /**
@@ -61,22 +50,23 @@ public TableMetadata getTableMetadata(Operation operation) throws ExecutionExcep
   }
 
   /**
-   * Returns a table metadata corresponding to the specified operation.
+   * Returns a table metadata corresponding to the specified namespace and table.
    *
    * @param namespace a namespace to retrieve
    * @param table a table to retrieve
    * @return a table metadata. null if the table is not found.
    * @throws ExecutionException if the operation fails
    */
+  @Nullable
   public TableMetadata getTableMetadata(String namespace, String table) throws ExecutionException {
     try {
       TableKey key = new TableKey(namespace, table);
-      return tableMetadataCache.get(key).orElse(null);
-    } catch (java.util.concurrent.ExecutionException e) {
+      return tableMetadataCache.get(key);
+    } catch (CompletionException e) {
       throw new ExecutionException(
           CoreError.GETTING_TABLE_METADATA_FAILED.buildMessage(
               ScalarDbUtils.getFullTableName(namespace, table)),
-          e);
+          e.getCause());
     }
   }
 

core/src/main/java/com/scalar/db/transaction/consensuscommit/TransactionTableMetadataManager.java

@@ -1,46 +1,39 @@
 package com.scalar.db.transaction.consensuscommit;
 
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.benmanes.caffeine.cache.LoadingCache;
 import com.scalar.db.api.DistributedStorageAdmin;
 import com.scalar.db.api.Operation;
 import com.scalar.db.api.TableMetadata;
 import com.scalar.db.common.CoreError;
 import com.scalar.db.exception.storage.ExecutionException;
 import com.scalar.db.util.ScalarDbUtils;
 import java.util.Objects;
-import java.util.Optional;
+import java.util.concurrent.CompletionException;
 import java.util.concurrent.TimeUnit;
-import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
 
 @ThreadSafe
 public class TransactionTableMetadataManager {
 
-  private final LoadingCache<TableKey, Optional<TransactionTableMetadata>> tableMetadataCache;
+  private final LoadingCache<TableKey, TransactionTableMetadata> tableMetadataCache;
 
   public TransactionTableMetadataManager(
       DistributedStorageAdmin admin, long cacheExpirationTimeSecs) {
 
-    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder();
+    Caffeine<Object, Object> builder = Caffeine.newBuilder();
     if (cacheExpirationTimeSecs >= 0) {
       builder.expireAfterWrite(cacheExpirationTimeSecs, TimeUnit.SECONDS);
     }
     tableMetadataCache =
         builder.build(
-            new CacheLoader<TableKey, Optional<TransactionTableMetadata>>() {
-              @Nonnull
-              @Override
-              public Optional<TransactionTableMetadata> load(@Nonnull TableKey key)
-                  throws ExecutionException {
-                TableMetadata tableMetadata = admin.getTableMetadata(key.namespace, key.table);
-                if (tableMetadata == null) {
-                  return Optional.empty();
-                }
-                return Optional.of(new TransactionTableMetadata(tableMetadata));
+            key -> {
+              TableMetadata tableMetadata = admin.getTableMetadata(key.namespace, key.table);
+              if (tableMetadata == null) {
+                return null;
               }
+              return new TransactionTableMetadata(tableMetadata);
             });
   }
 
@@ -74,12 +67,12 @@ public TransactionTableMetadata getTransactionTableMetadata(String namespace, St
       throws ExecutionException {
     try {
       TableKey key = new TableKey(namespace, table);
-      return tableMetadataCache.get(key).orElse(null);
-    } catch (java.util.concurrent.ExecutionException e) {
+      return tableMetadataCache.get(key);
+    } catch (CompletionException e) {
       throw new ExecutionException(
           CoreError.GETTING_TABLE_METADATA_FAILED.buildMessage(
               ScalarDbUtils.getFullTableName(namespace, table)),
-          e);
+          e.getCause());
     }
   }