feat: Use new certificate refresh logic

This will make the certificate refresh timing in the java jdbc connector consistent with the other connectors.

Author: hessjcg

core/src/main/java/com/google/cloud/sql/core/CloudSqlInstance.java

@@ -55,10 +55,6 @@ class CloudSqlInstance {
 
   private static final Logger logger = Logger.getLogger(CloudSqlInstance.class.getName());
   private static final String SQL_LOGIN_SCOPE = "https://www.googleapis.com/auth/sqlservice.login";
-  // defaultRefreshBuffer is the minimum amount of time for which a
-  // certificate must be valid to ensure the next refresh attempt has adequate
-  // time to complete.
-  private static final Duration DEFAULT_REFRESH_BUFFER = Duration.ofMinutes(4);
 
   private final ListeningScheduledExecutorService executor;
   private final SqlAdminApiFetcher apiFetcher;
@@ -71,6 +67,8 @@ class CloudSqlInstance {
   private final RateLimiter<Object> forcedRenewRateLimiter =
       RateLimiter.burstyBuilder(2, Duration.ofSeconds(30)).build();
 
+  private final RefreshCalculator refreshCalculator = new RefreshCalculator();
+
   @GuardedBy("instanceDataGuard")
   private ListenableFuture<InstanceData> currentInstanceData;
 
@@ -112,22 +110,6 @@ class CloudSqlInstance {
     }
   }
 
-  static long secondsUntilRefresh(Date expiration) {
-    Duration timeUntilExp = Duration.between(Instant.now(), expiration.toInstant());
-
-    if (timeUntilExp.compareTo(Duration.ofHours(1)) < 0) {
-      if (timeUntilExp.compareTo(DEFAULT_REFRESH_BUFFER) < 0) {
-        // If the time until the certificate expires is less the refresh buffer, schedule the
-        // refresh immediately
-        return 0;
-      }
-      // Otherwise schedule a refresh in (timeUntilExp - buffer) seconds
-      return timeUntilExp.minus(DEFAULT_REFRESH_BUFFER).getSeconds();
-    }
-    // If the time until the certificate expires is longer than an hour, return timeUntilExp//2
-    return timeUntilExp.dividedBy(2).getSeconds();
-  }
-
   static GoogleCredentials getDownscopedCredentials(OAuth2Credentials credentials) {
     GoogleCredentials downscoped;
     try {
@@ -270,7 +252,8 @@ public void onSuccess(InstanceData instanceData) {
               nextInstanceData =
                   executor.schedule(
                       () -> performRefresh(),
-                      secondsUntilRefresh(getInstanceData().getExpiration()),
+                      refreshCalculator.calculateSecondsUntilNextRefresh(
+                          Instant.now(), getInstanceData().getExpiration().toInstant()),
                       TimeUnit.SECONDS);
             }
           }

core/src/main/java/com/google/cloud/sql/core/RefreshCalculator.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.cloud.sql.core;
+
+import java.time.Duration;
+import java.time.Instant;
+
+/**
+ * RefreshCalculator determines the number of seconds until the next refresh operation using the
+ * same algorithm used by the other Connectors.
+ */
+class RefreshCalculator {
+
+  // defaultRefreshBuffer is the minimum amount of time for which a
+  // certificate must be valid to ensure the next refresh attempt has adequate
+  // time to complete.
+  private static final Duration DEFAULT_REFRESH_BUFFER = Duration.ofMinutes(4);
+
+  long calculateSecondsUntilNextRefresh(Instant now, Instant expiration) {
+    Duration timeUntilExp = Duration.between(now, expiration);
+
+    if (timeUntilExp.compareTo(Duration.ofHours(1)) < 0) {
+      if (timeUntilExp.compareTo(DEFAULT_REFRESH_BUFFER) < 0) {
+        // If the time until the certificate expires is less the refresh buffer, schedule the
+        // refresh immediately
+        return 0;
+      }
+      // Otherwise schedule a refresh in (timeUntilExp - buffer) seconds
+      return timeUntilExp.minus(DEFAULT_REFRESH_BUFFER).getSeconds();
+    }
+
+    // If the time until the certificate expires is longer than an hour, return timeUntilExp//2
+    return timeUntilExp.dividedBy(2).getSeconds();
+  }
+}

core/src/test/java/com/google/cloud/sql/core/CloudSqlInstanceTest.java

@@ -23,10 +23,6 @@
 
 import com.google.auth.oauth2.GoogleCredentials;
 import com.google.auth.oauth2.OAuth2Credentials;
-import java.time.Duration;
-import java.time.Instant;
-import java.util.Date;
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -67,26 +63,4 @@ public void throwsErrorForWrongCredentialType() {
         .hasMessageThat()
         .contains("Failed to downscope credentials for IAM Authentication");
   }
-
-  @Test
-  public void timeUntilRefreshImmediate() {
-    Date expiration = Date.from(Instant.now().plus(Duration.ofMinutes(3)));
-    assertThat(CloudSqlInstance.secondsUntilRefresh(expiration)).isEqualTo(0L);
-  }
-
-  @Test
-  public void timeUntilRefresh1Hr() {
-    Date expiration = Date.from(Instant.now().plus(Duration.ofMinutes(59)));
-    long expected = Duration.ofMinutes(59).minus(Duration.ofMinutes(4)).getSeconds();
-    Assert.assertEquals(
-        (float) CloudSqlInstance.secondsUntilRefresh(expiration), (float) expected, 1);
-  }
-
-  @Test
-  public void timeUntilRefresh24Hr() {
-    Date expiration = Date.from(Instant.now().plus(Duration.ofHours(23)));
-    long expected = Duration.ofHours(23).dividedBy(2).getSeconds();
-    Assert.assertEquals(
-        (float) CloudSqlInstance.secondsUntilRefresh(expiration), (float) expected, 1);
-  }
 }

core/src/test/java/com/google/cloud/sql/core/RefreshCalculatorTest.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.cloud.sql.core;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.time.temporal.ChronoUnit.SECONDS;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Arrays;
+import java.util.Collection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class RefreshCalculatorTest {
+
+  private final Duration input;
+  private final Duration want;
+
+  @Parameters(name = "Test {0}: calculateSecondsUntilNextRefresh({1})={2}")
+  public static Collection<Object[]> data() {
+    return Arrays.asList(
+        new Object[][] {
+          {"when expiration is greater than 1 hour", Duration.ofHours(4), Duration.ofHours(2)},
+          {"when expiration is equal to 1 hour", Duration.ofHours(1), Duration.ofMinutes(30)},
+          {
+            "when expiration is less than 1 hour, but greater than 4 minutes",
+            Duration.ofMinutes(5),
+            Duration.ofMinutes(1)
+          },
+          {"when expiration is less than 4 minutes", Duration.ofMinutes(3), Duration.ofMinutes(0)},
+          {"when expiration is now", Duration.ofMinutes(0), Duration.ofMinutes(0)},
+          {"when expiration is 62 minutes", Duration.ofMinutes(62), Duration.ofMinutes(31)},
+          {"when expiration is 58 minutes", Duration.ofMinutes(58), Duration.ofMinutes(54)},
+        });
+  }
+
+  public RefreshCalculatorTest(String name, Duration input, Duration want) {
+    this.input = input;
+    this.want = want;
+    this.refreshCalculator = new RefreshCalculator();
+  }
+
+  private static final Instant NOW = Instant.now().truncatedTo(SECONDS);
+  private RefreshCalculator refreshCalculator;
+
+  @Test
+  public void testDuration() {
+    Duration nextRefresh =
+        Duration.ofSeconds(
+            refreshCalculator.calculateSecondsUntilNextRefresh(NOW, NOW.plus(input)));
+    assertThat(nextRefresh).isEqualTo(want);
+  }
+}