Remove nested transaction from requestDnsRefresh (#2044)

* Remove nested transaction from requestDnsRefresh

* Add a bulk version

* Remove transaction time as field

* Only add delay once

* have PublishDnsUpdatesAction use bulk refresh

core/src/main/java/google/registry/dns/DnsUtils.java

@@ -17,6 +17,7 @@ package google.registry.dns;
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static google.registry.persistence.transaction.TransactionManagerFactory.tm;
 
+import com.google.common.collect.ImmutableCollection;
 import com.google.common.collect.ImmutableList;
 import com.google.common.net.InternetDomainName;
 import google.registry.model.common.DnsRefreshRequest;
@@ -36,28 +37,53 @@ public final class DnsUtils {
   private DnsUtils() {}
 
   private static void requestDnsRefresh(String name, TargetType type, Duration delay) {
+    tm().assertInTransaction();
     // Throws an IllegalArgumentException if the name is not under a managed TLD -- we only update
     // DNS for names that are under our management.
     String tld = Tlds.findTldForNameOrThrow(InternetDomainName.from(name)).toString();
-    tm().transact(
-            () ->
-                tm().insert(
+    tm().insert(new DnsRefreshRequest(type, name, tld, tm().getTransactionTime().plus(delay)));
+  }
+
+  private static void requestDnsRefresh(
+      ImmutableCollection<String> names, TargetType type, Duration delay) {
+    tm().assertInTransaction();
+    DateTime requestTime = tm().getTransactionTime().plus(delay);
+    tm().insertAll(
+            names.stream()
+                .map(
+                    name ->
                         new DnsRefreshRequest(
-                            type, name, tld, tm().getTransactionTime().plus(delay))));
+                            type,
+                            name,
+                            Tlds.findTldForNameOrThrow(InternetDomainName.from(name)).toString(),
+                            requestTime))
+                .collect(toImmutableList()));
   }
 
   public static void requestDomainDnsRefresh(String domainName, Duration delay) {
     requestDnsRefresh(domainName, TargetType.DOMAIN, delay);
   }
 
+  public static void requestDomainDnsRefresh(ImmutableCollection<String> names, Duration delay) {
+    requestDnsRefresh(names, TargetType.DOMAIN, delay);
+  }
+
   public static void requestDomainDnsRefresh(String domainName) {
     requestDomainDnsRefresh(domainName, Duration.ZERO);
   }
 
+  public static void requestDomainDnsRefresh(ImmutableCollection<String> names) {
+    requestDomainDnsRefresh(names, Duration.ZERO);
+  }
+
   public static void requestHostDnsRefresh(String hostName) {
     requestDnsRefresh(hostName, TargetType.HOST, Duration.ZERO);
   }
 
+  public static void requestHostDnsRefresh(ImmutableCollection<String> hostNames) {
+    requestDnsRefresh(hostNames, TargetType.HOST, Duration.ZERO);
+  }
+
   /**
    * Returns pending DNS update requests that need further processing up to batch size, in ascending
    * order of their request time, and updates their processing time to now.

core/src/main/java/google/registry/dns/PublishDnsUpdatesAction.java

@@ -26,6 +26,7 @@ import static google.registry.dns.DnsUtils.DNS_PUBLISH_PUSH_QUEUE_NAME;
 import static google.registry.dns.DnsUtils.requestDomainDnsRefresh;
 import static google.registry.dns.DnsUtils.requestHostDnsRefresh;
 import static google.registry.model.EppResourceUtils.loadByForeignKey;
+import static google.registry.persistence.transaction.TransactionManagerFactory.tm;
 import static google.registry.request.Action.Method.POST;
 import static google.registry.request.RequestParameters.PARAM_TLD;
 import static google.registry.util.CollectionUtils.nullToEmpty;
@@ -34,6 +35,7 @@ import static javax.servlet.http.HttpServletResponse.SC_ACCEPTED;
 import com.google.common.base.Joiner;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableSet;
 import com.google.common.flogger.FluentLogger;
 import com.google.common.net.InternetDomainName;
 import dagger.Lazy;
@@ -354,12 +356,11 @@ public final class PublishDnsUpdatesAction implements Runnable, Callable<Void> {
   /** Adds all the domains and hosts in the batch back to the queue to be processed later. */
   private void requeueBatch() {
     logger.atInfo().log("Requeueing batch for retry.");
-    for (String domain : nullToEmpty(domains)) {
-      requestDomainDnsRefresh(domain);
-    }
-    for (String host : nullToEmpty(hosts)) {
-      requestHostDnsRefresh(host);
-    }
+    tm().transact(
+            () -> {
+              requestDomainDnsRefresh(ImmutableSet.copyOf(nullToEmpty(domains)));
+              requestHostDnsRefresh(ImmutableSet.copyOf(nullToEmpty(hosts)));
+            });
   }
 
   /** Returns if the lock parameters are valid for this action. */

core/src/main/java/google/registry/dns/RefreshDnsAction.java

@@ -17,6 +17,7 @@ package google.registry.dns;
 import static google.registry.dns.DnsUtils.requestDomainDnsRefresh;
 import static google.registry.dns.DnsUtils.requestHostDnsRefresh;
 import static google.registry.model.EppResourceUtils.loadByForeignKey;
+import static google.registry.persistence.transaction.TransactionManagerFactory.tm;
 
 import google.registry.dns.DnsUtils.TargetType;
 import google.registry.model.EppResource;
@@ -59,18 +60,21 @@ public final class RefreshDnsAction implements Runnable {
     if (!domainOrHostName.contains(".")) {
       throw new BadRequestException("URL parameter 'name' must be fully qualified");
     }
-    switch (type) {
-      case DOMAIN:
-        loadAndVerifyExistence(Domain.class, domainOrHostName);
-        requestDomainDnsRefresh(domainOrHostName);
-        break;
-      case HOST:
-        verifyHostIsSubordinate(loadAndVerifyExistence(Host.class, domainOrHostName));
-        requestHostDnsRefresh(domainOrHostName);
-        break;
-      default:
-        throw new BadRequestException("Unsupported type: " + type);
-    }
+    tm().transact(
+            () -> {
+              switch (type) {
+                case DOMAIN:
+                  loadAndVerifyExistence(Domain.class, domainOrHostName);
+                  requestDomainDnsRefresh(domainOrHostName);
+                  break;
+                case HOST:
+                  verifyHostIsSubordinate(loadAndVerifyExistence(Host.class, domainOrHostName));
+                  requestHostDnsRefresh(domainOrHostName);
+                  break;
+                default:
+                  throw new BadRequestException("Unsupported type: " + type);
+              }
+            });
   }
 
   private <T extends EppResource & ForeignKeyedEppResource>