Use raw EntityManager to load during beforeSqlSave (#1253)

If we use the transaction manager methods, JpaTransactionManagerImpl
will attempt to detach the EppResource in question that we're loading --
this fails because that entity has been saved in the same transaction
already. We don't need detaching during these methods (it's just for
resource population) so we can use the raw loads to get around it.

core/src/main/java/google/registry/backup/ReplayCommitLogsToSqlAction.java

@@ -239,7 +239,7 @@ public class ReplayCommitLogsToSqlAction implements Runnable {
           .toSqlEntity()
           .ifPresent(
               sqlEntity -> {
-                ReplaySpecializer.beforeSqlSave(sqlEntity);
+                sqlEntity.beforeSqlSaveOnReplay();
                 jpaTm().put(sqlEntity);
               });
     } else {

core/src/main/java/google/registry/model/contact/ContactHistory.java

@@ -136,9 +136,11 @@ public class ContactHistory extends HistoryEntry implements SqlEntity {
   }
 
   // Used to fill out the contactBase field during asynchronous replay
-  public static void beforeSqlSave(ContactHistory contactHistory) {
-    contactHistory.contactBase =
-        jpaTm().loadByKey(VKey.createSql(ContactResource.class, contactHistory.getContactRepoId()));
+  @Override
+  public void beforeSqlSaveOnReplay() {
+    if (contactBase == null) {
+      contactBase = jpaTm().getEntityManager().find(ContactResource.class, getContactRepoId());
+    }
   }
 
   /** Class to represent the composite primary key of {@link ContactHistory} entity. */

core/src/main/java/google/registry/model/domain/DomainHistory.java

@@ -294,9 +294,26 @@ public class DomainHistory extends HistoryEntry implements SqlEntity {
   }
 
   // Used to fill out the domainContent field during asynchronous replay
-  public static void beforeSqlSave(DomainHistory domainHistory) {
-    domainHistory.domainContent =
-        jpaTm().loadByKey(VKey.createSql(DomainBase.class, domainHistory.getDomainRepoId()));
+  @Override
+  public void beforeSqlSaveOnReplay() {
+    if (domainContent == null) {
+      domainContent = jpaTm().getEntityManager().find(DomainBase.class, getDomainRepoId());
+      fillAuxiliaryFieldsFromDomain(this);
+    }
+  }
+
+  private static void fillAuxiliaryFieldsFromDomain(DomainHistory domainHistory) {
+    if (domainHistory.domainContent != null) {
+      domainHistory.nsHosts = nullToEmptyImmutableCopy(domainHistory.domainContent.nsHosts);
+      domainHistory.dsDataHistories =
+          nullToEmptyImmutableCopy(domainHistory.domainContent.getDsData()).stream()
+              .map(dsData -> DomainDsDataHistory.createFrom(domainHistory.id, dsData))
+              .collect(toImmutableSet());
+      domainHistory.gracePeriodHistories =
+          nullToEmptyImmutableCopy(domainHistory.domainContent.getGracePeriods()).stream()
+              .map(gracePeriod -> GracePeriodHistory.createFrom(domainHistory.id, gracePeriod))
+              .collect(toImmutableSet());
+    }
   }
 
   /** Class to represent the composite primary key of {@link DomainHistory} entity. */
@@ -391,17 +408,7 @@ public class DomainHistory extends HistoryEntry implements SqlEntity {
       // Note that we cannot assert that instance.domainContent is not null here because this
       // builder is also used to convert legacy HistoryEntry objects to DomainHistory, when
       // domainContent is not available.
-      if (instance.domainContent != null) {
-        instance.nsHosts = nullToEmptyImmutableCopy(instance.domainContent.nsHosts);
-        instance.dsDataHistories =
-            nullToEmptyImmutableCopy(instance.domainContent.getDsData()).stream()
-                .map(dsData -> DomainDsDataHistory.createFrom(instance.id, dsData))
-                .collect(toImmutableSet());
-        instance.gracePeriodHistories =
-            nullToEmptyImmutableCopy(instance.domainContent.getGracePeriods()).stream()
-                .map(gracePeriod -> GracePeriodHistory.createFrom(instance.id, gracePeriod))
-                .collect(toImmutableSet());
-      }
+      fillAuxiliaryFieldsFromDomain(instance);
       return instance;
     }
   }

core/src/main/java/google/registry/model/host/HostHistory.java

@@ -136,9 +136,11 @@ public class HostHistory extends HistoryEntry implements SqlEntity {
   }
 
   // Used to fill out the hostBase field during asynchronous replay
-  public static void beforeSqlSave(HostHistory hostHistory) {
-    hostHistory.hostBase =
-        jpaTm().loadByKey(VKey.createSql(HostResource.class, hostHistory.getHostRepoId()));
+  @Override
+  public void beforeSqlSaveOnReplay() {
+    if (hostBase == null) {
+      hostBase = jpaTm().getEntityManager().find(HostResource.class, getHostRepoId());
+    }
   }
 
   /** Class to represent the composite primary key of {@link HostHistory} entity. */

core/src/main/java/google/registry/schema/replay/ReplaySpecializer.java

@@ -28,17 +28,11 @@ import java.lang.reflect.Method;
 public class ReplaySpecializer {
 
   public static void beforeSqlDelete(VKey<?> key) {
-    invokeMethod(key.getKind(), "beforeSqlDelete", key);
-  }
-
-  public static void beforeSqlSave(SqlEntity sqlEntity) {
-    invokeMethod(sqlEntity.getClass(), "beforeSqlSave", sqlEntity);
-  }
-
-  private static <T> void invokeMethod(Class<T> clazz, String methodName, Object argument) {
+    String methodName = "beforeSqlDelete";
+    Class<?> clazz = key.getKind();
     try {
-      Method method = clazz.getMethod(methodName, argument.getClass());
-      method.invoke(null, argument);
+      Method method = clazz.getMethod(methodName, VKey.class);
+      method.invoke(null, key);
     } catch (NoSuchMethodException e) {
       // Ignore, this just means that the class doesn't need this hook.
     } catch (IllegalAccessException e) {

core/src/main/java/google/registry/schema/replay/SqlEntity.java

@@ -26,4 +26,7 @@ import java.util.Optional;
 public interface SqlEntity {
 
   Optional<DatastoreEntity> toDatastoreEntity();
+
+  /** A method that will ber called before the object is saved to SQL in asynchronous replay. */
+  default void beforeSqlSaveOnReplay() {}
 }

core/src/main/java/google/registry/tools/javascrap/CreateSyntheticHistoryEntriesAction.java

@@ -53,7 +53,7 @@ import javax.inject.Inject;
  * However, since this is meant to be run during the Datastore-primary, SQL-secondary stage of the
  * migration, we want to make sure that we are using the most up-to-date version of the data. The
  * resource field of the history objects will be populated during asynchronous migration, e.g. in
- * {@link DomainHistory#beforeSqlSave(DomainHistory)}.
+ * {@link DomainHistory#beforeSqlSaveOnReplay}.
  */
 @Action(
     service = Action.Service.BACKEND,