From 54c54fda42e49d077b1784f4940d20317e701d25 Mon Sep 17 00:00:00 2001
From: Prashant <prashant.thakre@gmail.com>
Date: Tue, 17 Feb 2026 10:50:34 +0000
Subject: [PATCH] Migrate to caffeine 3 (#594)

---
 opendj-server-legacy/src/main/java/org/opends/server/backends/jdbc/CachedConnection.java |   72 +++++++++++++++--------------------
 1 files changed, 31 insertions(+), 41 deletions(-)

diff --git a/opendj-server-legacy/src/main/java/org/opends/server/backends/jdbc/CachedConnection.java b/opendj-server-legacy/src/main/java/org/opends/server/backends/jdbc/CachedConnection.java
index 809404d..7d36e4e 100644
--- a/opendj-server-legacy/src/main/java/org/opends/server/backends/jdbc/CachedConnection.java
+++ b/opendj-server-legacy/src/main/java/org/opends/server/backends/jdbc/CachedConnection.java
@@ -15,72 +15,66 @@
  */
 package org.opends.server.backends.jdbc;
 
-import com.google.common.cache.*;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.benmanes.caffeine.cache.LoadingCache;
+import com.github.benmanes.caffeine.cache.RemovalCause;
 
 import java.sql.*;
-import java.util.LinkedList;
+import java.time.Duration;
 import java.util.Map;
 import java.util.Properties;
-import java.util.Queue;
 import java.util.concurrent.*;
 
 public class CachedConnection implements Connection {
     final Connection parent;
 
-    static LoadingCache<String, BlockingQueue<CachedConnection>> cached= CacheBuilder.newBuilder()
-            .expireAfterAccess(Long.parseLong(System.getProperty("org.openidentityplatform.opendj.jdbc.ttl","15000")), TimeUnit.MILLISECONDS)
-            .removalListener(new RemovalListener<String, BlockingQueue<CachedConnection>>() {
-                @Override
-                public void onRemoval(RemovalNotification<String, BlockingQueue<CachedConnection>> notification) {
-                    assert notification.getValue() != null;
-                    for (CachedConnection con: notification.getValue()) {
-                            try {
-                                if (!con.isClosed()) {
-                                    con.parent.close();
-                                }
-                            } catch (SQLException e) {
-                            }
-                        }
+    static LoadingCache<String, BlockingQueue<CachedConnection>> cached = Caffeine.newBuilder()
+        .expireAfterAccess(Duration.ofMillis(Long.parseLong(System.getProperty("org.openidentityplatform.opendj.jdbc.ttl","15000"))))
+        .removalListener((String key, BlockingQueue<CachedConnection> value, RemovalCause cause) -> {
+            for (CachedConnection con : value) {
+                try {
+                    if (!con.isClosed()) {
+                        con.parent.close();
+                    }
+                } catch (SQLException e) {
+                    // ignore
                 }
-            })
-            .build(new CacheLoader<String, BlockingQueue<CachedConnection>>() {
-                @Override
-                public BlockingQueue<CachedConnection> load(String connectionString) throws Exception {
-                    return new LinkedBlockingQueue<>();
-                }
-            });
+            }
+        })
+        .build(conStr -> new LinkedBlockingQueue<>());
 
     final String connectionString;
-    public CachedConnection(String connectionString,Connection parent) {
-        this.connectionString=connectionString;
+    public CachedConnection(String connectionString, Connection parent) {
+        this.connectionString = connectionString;
         this.parent = parent;
     }
 
     static Connection getConnection(String connectionString) throws Exception {
-        return getConnection(connectionString,0);
+        return getConnection(connectionString, 0);
     }
 
     static Connection getConnection(String connectionString, final int waitTime) throws Exception {
-        CachedConnection con=cached.get(connectionString).poll(waitTime,TimeUnit.MILLISECONDS);
-        while(con!=null) {
+        CachedConnection con = cached.get(connectionString).poll(waitTime, TimeUnit.MILLISECONDS);
+
+        while (con != null) {
             if (!con.isValid(0)) {
                 try {
                     con.parent.close();
                 } catch (SQLException e) {
-                    con=null;
+                    con = null;
                 }
-                con=cached.get(connectionString).poll();
-            }else{
+                con = cached.get(connectionString).poll();
+            } else {
                 return con;
             }
         }
         try {
-            final Connection conNew= DriverManager.getConnection(connectionString);
+            final Connection conNew = DriverManager.getConnection(connectionString);
             conNew.setAutoCommit(false);
             conNew.setTransactionIsolation(TRANSACTION_READ_COMMITTED);
             return new CachedConnection(connectionString, conNew);
-        }catch (SQLException e) { //max_connection server error: try recursion for reuse connection
-            return getConnection(connectionString,(waitTime==0)?1:waitTime*2);
+        } catch (SQLException e) { // max_connection server error: try recursion for reuse connection
+            return getConnection(connectionString, (waitTime == 0) ? 1 : waitTime * 2);
         }
     }
 
@@ -127,11 +121,7 @@
     @Override
     public void close() throws SQLException {
         rollback();
-        try {
-            cached.get(connectionString).add(this);
-        } catch (ExecutionException e) {
-            throw new RuntimeException(e);
-        }
+        cached.get(connectionString).add(this);
     }
 
     @Override
@@ -196,7 +186,7 @@
 
     @Override
     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
-        return parent.prepareCall(sql, resultSetType, resultSetConcurrency) ;
+        return parent.prepareCall(sql, resultSetType, resultSetConcurrency);
     }
 
     @Override

--
Gitblit v1.10.0