core: combined epoch seconds and nanos changes in TimeProvider

core/src/main/java/io/grpc/internal/ConcurrentTimeProvider.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2024 The gRPC Authors
+ *
+ * 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
+ *
+ *     http://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 io.grpc.internal;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * {@link ConcurrentTimeProvider} resolves ConcurrentTimeProvider which implements
+ * {@link TimeProvider}.
+ */
+
+final class ConcurrentTimeProvider implements TimeProvider {
+
+  @Override
+  public long currentTimeNanos() {
+    return TimeUnit.MILLISECONDS.toNanos(System.currentTimeMillis());
+  }
+}

core/src/main/java/io/grpc/internal/InstantTimeProvider.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2024 The gRPC Authors
+ *
+ * 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
+ *
+ *     http://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 io.grpc.internal;
+
+/**
+ * {@link InstantTimeProvider} resolves InstantTimeProvider which implements {@link TimeProvider}.
+ */
+
+final class InstantTimeProvider implements TimeProvider {
+
+  private Class<?> instantClass;
+
+  public InstantTimeProvider(Class<?> instantClass) {
+    this.instantClass = instantClass;
+  }
+
+  @Override
+  public long currentTimeNanos() {
+    try {
+      Object instant = instantClass.getMethod("now").invoke(null);
+      int nanos = (int) instantClass.getMethod("getNano").invoke(instant);
+      long epochSeconds = (long) instantClass.getMethod("getEpochSecond").invoke(instant);
+      return epochSeconds * 1_000_000_000L + nanos;
+    } catch (Exception ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+}

core/src/main/java/io/grpc/internal/TimeProvider.java

@@ -16,8 +16,6 @@
 
 package io.grpc.internal;
 
-import java.util.concurrent.TimeUnit;
-
 /**
  * Time source representing the current system time in nanos. Used to inject a fake clock
  * into unit tests.
@@ -26,10 +24,5 @@ public interface TimeProvider {
   /** Returns the current nano time. */
   long currentTimeNanos();
 
-  TimeProvider SYSTEM_TIME_PROVIDER = new TimeProvider() {
-    @Override
-    public long currentTimeNanos() {
-      return TimeUnit.MILLISECONDS.toNanos(System.currentTimeMillis());
-    }
-  };
+  TimeProvider SYSTEM_TIME_PROVIDER = TimeProviderResolverFactory.resolveTimeProvider();
 }

core/src/main/java/io/grpc/internal/TimeProviderResolverFactory.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2024 The gRPC Authors
+ *
+ * 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
+ *
+ *     http://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 io.grpc.internal;
+
+/**
+ * {@link TimeProviderResolverFactory} resolves Time providers.
+ */
+
+final class TimeProviderResolverFactory {
+
+  private static final Class<?> INSTANT_CLASS = initInstant();
+
+  private static Class<?> initInstant() {
+    try {
+      return Class.forName("java.time.Instant");
+    } catch (Exception ex) {
+      return null;
+    }
+  }
+
+  static TimeProvider resolveTimeProvider() {
+    if (INSTANT_CLASS == null) {
+      return new ConcurrentTimeProvider();
+    } else {
+      return new InstantTimeProvider(INSTANT_CLASS);
+    }
+  }
+}

core/src/test/java/io/grpc/internal/InstantTimeProviderTest.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2024 The gRPC Authors
+ *
+ * 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
+ *
+ *     http://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 io.grpc.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import java.time.Instant;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link InstantTimeProvider}.
+ */
+@RunWith(JUnit4.class)
+public class InstantTimeProviderTest {
+
+  @Test
+  public void testConcurrentCurrentTimeNanos() {
+
+    ConcurrentTimeProvider concurrentTimeProvider = new ConcurrentTimeProvider();
+    // Get the current time from the TimeProvider
+    long actualTimeNanos = concurrentTimeProvider.currentTimeNanos();
+
+    // Get the current time from Instant for comparison
+    Instant instantNow = Instant.now();
+    long expectedTimeNanos = instantNow.getEpochSecond() * 1_000_000_000L + instantNow.getNano();
+
+    // Validate the time returned is close to the expected value within a tolerance
+    // (i,e 10 millisecond tolerance in nanoseconds).
+    assertThat(actualTimeNanos).isWithin(10_000_000L).of(expectedTimeNanos);
+  }
+
+  @Test
+  public void testInstantCurrentTimeNanos() {
+    try {
+      InstantTimeProvider instantTimeProvider = new InstantTimeProvider(
+          Class.forName("java.time.Instant"));
+
+      // Get the current time from the TimeProvider
+      long actualTimeNanos = instantTimeProvider.currentTimeNanos();
+
+      // Get the current time from Instant for comparison
+      Instant instantNow = Instant.now();
+      long expectedTimeNanos = instantNow.getEpochSecond() * 1_000_000_000L + instantNow.getNano();
+
+      // Validate the time returned is close to the expected value within a tolerance
+      // (i,e 10 millisecond tolerance in nanoseconds).
+      assertThat(actualTimeNanos).isWithin(10_000_000L).of(expectedTimeNanos);
+    } catch (ClassNotFoundException e) {
+      throw new RuntimeException(e);
+    }
+  }
+}