Complete Joda-Time to java.time migration

This completes the exhaustive refactoring of foundational temporal types from Joda-Time to the native java.time API across the entire codebase.

- Replaced org.joda.time.DateTime, Instant, LocalDate, and Duration with java.time equivalents.
- Audited and updated Clock implementations (FakeClock, SystemClock). Added nowMillis(), nowDate(), and nowDateTime() to eliminate repetitive conversions and maintain parallel naming.
- Replaced ZonedDateTime with OffsetDateTime globally per go/avoid-zdt. OffsetDateTime is a better fit as we use a hardcoded ZoneOffset.UTC throughout the system, making geographical time zone rules (like daylight saving time) irrelevant and preventing serialization ambiguities. Added a presubmit check.
- Completely removed all transitional bridge methods from DateTimeUtils and deleted obsolete converters (e.g., DateTimeConverter).
- Updated testing infrastructure, Apache Beam pipelines, custom JCommander parameters, and networking modules to solely rely on java.time primitives.
- Retained the lone necessary org.joda.time.Instant usage in SafeBrowsingTransforms required by the Apache Beam API.
- Cleared Gradle lockfiles and removed the joda-time dependency entirely from the build configuration.

Author: CydeWeys

GEMINI.md

@@ -58,7 +58,6 @@ dependencies {
   implementation deps['com.google.code.findbugs:jsr305']
   implementation deps['com.google.guava:guava']
   implementation deps['jakarta.inject:jakarta.inject-api']
-  implementation deps['joda-time:joda-time']
   implementation deps['com.google.flogger:flogger']
   implementation deps['io.github.java-diff-utils:java-diff-utils']
   implementation deps['com.google.truth:truth']

common/build.gradle

@@ -37,7 +37,7 @@ io.github.java-diff-utils:java-diff-utils:4.12=annotationProcessor,testAnnotatio
 io.github.java-diff-utils:java-diff-utils:4.16=compileClasspath,deploy_jar,runtimeClasspath,testCompileClasspath,testRuntimeClasspath,testing,testingCompileClasspath
 jakarta.inject:jakarta.inject-api:2.0.1=compileClasspath,deploy_jar,runtimeClasspath,testCompileClasspath,testRuntimeClasspath,testing,testingCompileClasspath
 javax.inject:javax.inject:1=annotationProcessor,testAnnotationProcessor,testingAnnotationProcessor
-joda-time:joda-time:2.14.2=compileClasspath,deploy_jar,runtimeClasspath,testCompileClasspath,testRuntimeClasspath,testing,testingCompileClasspath
+joda-time:joda-time:2.14.2=deploy_jar,testRuntimeClasspath,testing
 junit:junit:4.13.2=testCompileClasspath,testRuntimeClasspath,testing,testingCompileClasspath
 net.sf.saxon:Saxon-HE:12.5=checkstyle
 org.antlr:antlr4-runtime:4.13.2=checkstyle

common/gradle.lockfile

@@ -16,15 +16,16 @@
 
 import java.io.Serializable;
 import java.time.Instant;
+import java.time.LocalDate;
+import java.time.OffsetDateTime;
 import java.time.ZoneOffset;
-import java.time.ZonedDateTime;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
  * A clock that tells the current time in milliseconds or nanoseconds.
  *
  * <p>Clocks are technically serializable because they are either a stateless wrapper around the
- * system clock, or for testing, are just a wrapper around a DateTime. This means that if you
+ * system clock, or for testing, are just a wrapper around an Instant. This means that if you
  * serialize a clock and deserialize it elsewhere, you won't necessarily get the same time or time
  * zone -- what you will get is a functioning clock.
  */
@@ -34,8 +35,18 @@ public interface Clock extends Serializable {
   /** Returns current Instant (which is always in UTC). */
   Instant now();
 
-  /** Returns the current time as a {@link ZonedDateTime} in UTC. */
-  default ZonedDateTime nowDate() {
-    return ZonedDateTime.ofInstant(now(), ZoneOffset.UTC);
+  /** Returns the current time as an {@link OffsetDateTime} in UTC. */
+  default OffsetDateTime nowDateTime() {
+    return OffsetDateTime.ofInstant(now(), ZoneOffset.UTC);
+  }
+
+  /** Returns the current time as a {@link LocalDate} in UTC. */
+  default LocalDate nowDate() {
+    return LocalDate.ofInstant(now(), ZoneOffset.UTC);
+  }
+
+  /** Returns the current time in milliseconds since the epoch. */
+  default long nowMillis() {
+    return now().toEpochMilli();
   }
 }

common/src/main/java/google/registry/util/Clock.java

@@ -15,7 +15,6 @@
 package google.registry.util;
 
 import static com.google.common.base.Preconditions.checkArgument;
-import static org.joda.time.DateTimeZone.UTC;
 
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
@@ -24,14 +23,8 @@
 import java.time.LocalDate;
 import java.time.ZoneOffset;
 import java.time.format.DateTimeFormatter;
-import java.time.format.DateTimeFormatterBuilder;
 import java.time.format.DateTimeParseException;
-import java.time.format.SignStyle;
-import java.time.temporal.ChronoField;
 import java.time.temporal.ChronoUnit;
-import javax.annotation.Nullable;
-import org.joda.time.DateTime;
-import org.joda.time.ReadableDuration;
 
 public abstract class DateTimeUtils {
 
@@ -52,23 +45,24 @@ public abstract class DateTimeUtils {
    *
    * <p>Example: {@code 2024-03-27T10:15:30.105Z}
    *
-   * <p>Handles large/negative years by using a sign prefix if necessary, compatible with {@link
-   * Instant#parse}.
+   * <p>Note: We deliberately strip the leading {@code +} sign from the formatted year field if
+   * present. While standard ISO 8601 specifies that years with more than 4 digits should be
+   * prefixed with a {@code +} sign, W3C XML Schema 1.0 (which our EPP RDE XSD uses) strictly
+   * forbids leading plus signs in {@code xsd:dateTime} strings. Suppressing the plus sign ensures
+   * our generated XML continues to pass strict XSD validation for large years (e.g. {@code
+   * 294247-01-10T04:00:54.775Z}).
    */
   private static final DateTimeFormatter ISO_8601_FORMATTER =
-      new DateTimeFormatterBuilder()
-          .appendValue(ChronoField.YEAR, 4, 10, SignStyle.NOT_NEGATIVE)
-          .appendPattern("-MM-dd'T'HH:mm:ss.SSS'Z'")
-          .toFormatter()
-          .withZone(ZoneOffset.UTC);
+      DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").withZone(ZoneOffset.UTC);
 
   /** A formatter that produces lowercase, filename-safe and job-name-safe timestamps. */
   public static final DateTimeFormatter LOWERCASE_TIMESTAMP_FORMATTER =
       DateTimeFormatter.ofPattern("yyyy-MM-dd't'HH-mm-ss'z'").withZone(ZoneOffset.UTC);
 
   /** Formats an {@link Instant} to an ISO-8601 string. */
   public static String formatInstant(Instant instant) {
-    return ISO_8601_FORMATTER.format(instant);
+    String formatted = ISO_8601_FORMATTER.format(instant);
+    return formatted.startsWith("+") ? formatted.substring(1) : formatted;
   }
 
   /**
@@ -79,9 +73,15 @@ public static String formatInstant(Instant instant) {
    * large years (e.g. {@code 294247-01-10T04:00:54.775Z}).
    */
   public static Instant parseInstant(String timestamp) {
+    if (!timestamp.startsWith("+") && !timestamp.startsWith("-")) {
+      int dashIndex = timestamp.indexOf('-');
+      if (dashIndex > 4) {
+        timestamp = "+" + timestamp;
+      }
+    }
     try {
       // Try the standard millisecond precision format first.
-      return Instant.from(ISO_8601_FORMATTER.parse(timestamp));
+      return Instant.from(DateTimeFormatter.ISO_INSTANT.parse(timestamp));
     } catch (DateTimeParseException e) {
       // Fall back to the standard ISO instant parser which handles varied precision.
       return Instant.parse(timestamp);
@@ -93,7 +93,7 @@ public static Instant earliestOf(Instant first, Instant... rest) {
     return earliestOf(Lists.asList(first, rest));
   }
 
-  /** Returns the earliest element in a {@link Instant} iterable. */
+  /** Returns the earliest element in an {@link Instant} iterable. */
   public static Instant earliestOf(Iterable<Instant> instants) {
     checkArgument(!Iterables.isEmpty(instants));
     return Ordering.<Instant>natural().min(instants);
@@ -104,24 +104,12 @@ public static Instant latestOf(Instant first, Instant... rest) {
     return latestOf(Lists.asList(first, rest));
   }
 
-  /** Returns the latest element in a {@link Instant} iterable. */
+  /** Returns the latest element in an {@link Instant} iterable. */
   public static Instant latestOf(Iterable<Instant> instants) {
     checkArgument(!Iterables.isEmpty(instants));
     return Ordering.<Instant>natural().max(instants);
   }
 
-  /** Converts a Joda-Time Duration to a java.time.Duration. */
-  @Nullable
-  public static java.time.Duration toJavaDuration(@Nullable ReadableDuration duration) {
-    return duration == null ? null : java.time.Duration.ofMillis(duration.getMillis());
-  }
-
-  /** Converts a java.time.Duration to a Joda-Time Duration. */
-  @Nullable
-  public static org.joda.time.Duration toJodaDuration(@Nullable java.time.Duration duration) {
-    return duration == null ? null : org.joda.time.Duration.millis(duration.toMillis());
-  }
-
   /** Returns whether the first {@link Instant} is equal to or earlier than the second. */
   public static boolean isBeforeOrAt(Instant timeToCheck, Instant timeToCompareTo) {
     return !timeToCheck.isAfter(timeToCompareTo);
@@ -134,7 +122,7 @@ public static boolean isAtOrAfter(Instant timeToCheck, Instant timeToCompareTo)
 
   /**
    * Adds years to a date, in the {@code Duration} sense of semantic years. Use this instead of
-   * {@link java.time.ZonedDateTime#plusYears} to ensure that we never end up on February 29.
+   * {@link java.time.OffsetDateTime#plusYears} to ensure that we never end up on February 29.
    */
   public static Instant plusYears(Instant now, int years) {
     checkArgument(years >= 0);
@@ -157,7 +145,7 @@ public static Instant minusMonths(Instant now, int months) {
 
   /**
    * Subtracts years from a date, in the {@code Duration} sense of semantic years. Use this instead
-   * of {@link java.time.ZonedDateTime#minusYears} to ensure that we never end up on February 29.
+   * of {@link java.time.OffsetDateTime#minusYears} to ensure that we never end up on February 29.
    */
   public static Instant minusYears(Instant now, long years) {
     checkArgument(years >= 0);
@@ -171,24 +159,6 @@ public static LocalDate toLocalDate(Instant instant) {
     return instant.atZone(ZoneOffset.UTC).toLocalDate();
   }
 
-  /** Convert a joda {@link DateTime} to a java.time {@link Instant}, null-safe. */
-  @Nullable
-  public static Instant toInstant(@Nullable DateTime dateTime) {
-    return (dateTime == null) ? null : Instant.ofEpochMilli(dateTime.getMillis());
-  }
-
-  /** Convert a java.time {@link Instant} to a joda {@link DateTime}, null-safe. */
-  @Nullable
-  public static DateTime toDateTime(@Nullable Instant instant) {
-    return (instant == null) ? null : new DateTime(instant.toEpochMilli(), UTC);
-  }
-
-  /** Convert a java.time {@link java.time.Instant} to a joda {@link org.joda.time.Instant}. */
-  @Nullable
-  public static org.joda.time.Instant toJodaInstant(@Nullable java.time.Instant instant) {
-    return (instant == null) ? null : org.joda.time.Instant.ofEpochMilli(instant.toEpochMilli());
-  }
-
   public static Instant plusHours(Instant instant, long hours) {
     return instant.plus(hours, ChronoUnit.HOURS);
   }

common/src/main/java/google/registry/util/DateTimeUtils.java

@@ -31,10 +31,9 @@ public SystemClock() {}
 
   @Override
   public Instant now() {
-    // Truncate to milliseconds to match the precision of Joda DateTime and our database schema
-    // (which uses millisecond precision via DateTimeConverter). This prevents subtle comparison
-    // bugs where a high-precision Instant would be considered "after" a truncated database
-    // timestamp.
+    // Truncate to milliseconds to match the precision of our database schema.
+    // This prevents subtle comparison bugs where a high-precision Instant would be
+    // considered "after" a truncated database timestamp.
     return Instant.now().truncatedTo(MILLIS);
   }
 }

common/src/main/java/google/registry/util/SystemClock.java

@@ -21,8 +21,6 @@
 import java.time.Instant;
 import java.util.concurrent.atomic.AtomicLong;
 import javax.annotation.concurrent.ThreadSafe;
-import org.joda.time.ReadableDuration;
-import org.joda.time.ReadableInstant;
 
 /** A mock clock for testing purposes that supports telling, setting, and advancing the time. */
 @ThreadSafe
@@ -41,12 +39,6 @@ public FakeClock() {
     this(START_INSTANT);
   }
 
-  /** Creates a FakeClock initialized to a specific time. */
-  @Deprecated
-  public FakeClock(ReadableInstant startTime) {
-    setTo(startTime);
-  }
-
   /** Creates a FakeClock initialized to a specific time. */
   public FakeClock(Instant startTime) {
     setTo(startTime);
@@ -66,12 +58,6 @@ public Instant now() {
    * @param autoIncrementStep the new auto increment duration
    * @return this
    */
-  @Deprecated
-  public FakeClock setAutoIncrementStep(ReadableDuration autoIncrementStep) {
-    this.autoIncrementStepMs = autoIncrementStep.getMillis();
-    return this;
-  }
-
   /**
    * Sets the increment applied to the clock whenever it is queried. The increment is zero by
    * default: the clock is left unchanged when queried.
@@ -91,23 +77,11 @@ public void advanceOneMilli() {
     advanceBy(Duration.ofMillis(1));
   }
 
-  /** Advances clock by some duration. */
-  @Deprecated
-  public void advanceBy(ReadableDuration duration) {
-    currentTimeMillis.addAndGet(duration.getMillis());
-  }
-
   /** Advances clock by some duration. */
   public void advanceBy(Duration duration) {
     currentTimeMillis.addAndGet(duration.toMillis());
   }
 
-  /** Sets the time to the specified instant. */
-  @Deprecated
-  public void setTo(ReadableInstant time) {
-    currentTimeMillis.set(time.getMillis());
-  }
-
   /** Sets the time to the specified instant. */
   public void setTo(Instant time) {
     currentTimeMillis.set(time.toEpochMilli());

common/src/testing/java/google/registry/testing/FakeClock.java

@@ -409,4 +409,3 @@ def main(args) -> int:
         sys.exit(main(sys.argv))
     except Abort as ex:
         sys.exit(1)
-