Prober circular list

prober/src/main/java/google/registry/monitoring/blackbox/ProbingSequence.java

@@ -14,14 +14,22 @@
 
 package google.registry.monitoring.blackbox;
 
+import com.google.common.flogger.FluentLogger;
+import google.registry.monitoring.blackbox.exceptions.UndeterminedStateException;
 import google.registry.monitoring.blackbox.tokens.Token;
+import google.registry.util.AbstractCircularLinkedListIterator;
 import io.netty.bootstrap.Bootstrap;
 import io.netty.channel.AbstractChannel;
+import io.netty.channel.ChannelFuture;
 import io.netty.channel.EventLoopGroup;
 
 /**
  * Represents Sequence of {@link ProbingStep}s that the Prober performs in order.
  *
+ * <p>Inherits from {@link AbstractCircularLinkedListIterator}</p>, with element type of
+ * {@link ProbingStep} as the manner in which the sequence is carried out is analogous to the {@link
+ * AbstractCircularLinkedListIterator}
+ *
  *
  * <p>Created with {@link Builder} where we specify {@link EventLoopGroup}, {@link AbstractChannel}
  * class type, then sequentially add in the {@link ProbingStep.Builder}s in order and mark which one
@@ -31,78 +39,146 @@
  * the first one is activated with the requisite {@link Token}, the {@link ProbingStep}s do the rest
  * of the work.</p>
  */
-public class ProbingSequence {
+public class ProbingSequence extends AbstractCircularLinkedListIterator<ProbingStep> {
 
-  private ProbingStep firstStep;
+  private static final FluentLogger logger = FluentLogger.forEnclosingClass();
 
   /**
    * Each {@link ProbingSequence} requires a start token to begin running.
    */
   private Token startToken;
 
-  private ProbingSequence(ProbingStep firstStep, Token startToken) {
-    this.firstStep = firstStep;
+  private ProbingSequence(Entry<ProbingStep> first, Entry<ProbingStep> last, Token startToken) {
+    super(first, last);
     this.startToken = startToken;
   }
 
+  /**
+   * Starts ProbingSequence by calling first {@code runStep} with {@code startToken}.
+   */
   public void start() {
-    // calls the first step with startToken;
-    firstStep.accept(startToken);
+    runStep(startToken);
+  }
+
+  /**
+   * Generates new {@link ProbingAction} from {@link ProbingStep}, calls the action, then retrieves
+   * the result of the action.
+   *
+   * @param token - used to generate the {@link ProbingAction} by calling {@code
+   * get().generateAction}.
+   *
+   * <p>Moves on to next {@link ProbingStep} in the iterator and changes the {@link Token}
+   * to the next one if the previous step was the last one in the loop.</p>
+   *
+   * <p>If unable to generate the action, or the calling the action results in an immediate error,
+   * we note an error. Otherwise, if the future marked as finished when the action is completed is
+   * marked as a success, we note a success. Otherwise, if the cause of failure will either be a
+   * failure or error. </p>
+   */
+  private void runStep(Token token) {
+    Token finalToken;
+    if (get() == getLast()) {
+      finalToken = token.next();
+    } else {
+      finalToken = token;
+    }
+
+    //Calls next runStep
+    next();
+
+    ProbingAction currentAction;
+    //attempt to generate new action. On error, move on to next step
+    try {
+      currentAction = get().generateAction(finalToken);
+    } catch (UndeterminedStateException e) {
+      logger.atWarning().withCause(e).log("Error in Action Generation");
+      runStep(finalToken);
+      return;
+    }
+
+    ChannelFuture future;
+    try {
+      //call the generated action
+      future = currentAction.call();
+    } catch (Exception e) {
+      //On error in calling action, log error and note an error
+      logger.atWarning().withCause(e).log("Error in Action Performed");
+
+      //Calls next runStep
+      runStep(finalToken);
+      return;
+    }
+
+    future.addListener(f -> {
+      if (f.isSuccess()) {
+        //On a successful result, we log as a successful step, and not a success
+        logger.atInfo().log(String.format("Successfully completed Probing Step: %s", this));
+
+      } else {
+        //On a failed result, we log the failure and note either a failure or error
+        logger.atSevere().withCause(f.cause()).log("Did not result in future success");
+      }
+
+      if (get().protocol().persistentConnection()) {
+      //If the connection is persistent, we store the channel in the token
+
+        finalToken.setChannel(currentAction.channel());
+      }
+
+      //Calls next runStep
+      runStep(finalToken);
+
+
+    });
   }
 
   /**
    * Turns {@link ProbingStep.Builder}s into fully self-dependent sequence with supplied {@link
    * Bootstrap}.
    */
-  public static class Builder {
+  public static class Builder extends AbstractCircularLinkedListIterator.Builder<ProbingStep,
+      Builder, ProbingSequence> {
 
-    private ProbingStep currentStep;
-    private ProbingStep firstStep;
-    private ProbingStep firstRepeatedStep;
+    private Entry<ProbingStep> firstRepeatedStepEntry;
 
     private Token startToken;
 
+    /**
+     * This Builder must also be supplied with a {@link Token} to construct a {@link
+     * ProbingSequence}.
+     */
     public Builder(Token startToken) {
       this.startToken = startToken;
     }
 
     /**
-     * Adds {@link ProbingStep}, which is supplied with {@link Bootstrap}, built, and pointed to by
-     * the previous {@link ProbingStep} added.
+     * We take special note of the first repeated step.
      */
-    public Builder addStep(ProbingStep step) {
-
-      if (currentStep == null) {
-        firstStep = step;
-      } else {
-        currentStep.nextStep(step);
-      }
-
-      currentStep = step;
+    public Builder markFirstRepeated() {
+      firstRepeatedStepEntry = current;
       return this;
     }
 
     /**
-     * We take special note of the first repeated step.
+     * Returns this builder as childBuilder.
      */
-    public Builder markFirstRepeated() {
-      firstRepeatedStep = currentStep;
+    @Override
+    public Builder childBuilder() {
       return this;
     }
 
     /**
      * Points last {@link ProbingStep} to the {@code firstRepeatedStep} and calls private
      * constructor to create {@link ProbingSequence}.
      */
+    @Override
     public ProbingSequence build() {
-      if (firstRepeatedStep == null) {
-        firstRepeatedStep = firstStep;
+      if (firstRepeatedStepEntry == null) {
+        firstRepeatedStepEntry = first;
       }
 
-      currentStep.nextStep(firstRepeatedStep);
-      currentStep.lastStep();
-      return new ProbingSequence(this.firstStep, this.startToken);
+      current.setNext(firstRepeatedStepEntry);
+      return new ProbingSequence(first, current, startToken);
     }
   }
 }
-

prober/src/main/java/google/registry/monitoring/blackbox/ProbingStep.java

@@ -15,13 +15,10 @@
 package google.registry.monitoring.blackbox;
 
 import com.google.auto.value.AutoValue;
-import com.google.common.flogger.FluentLogger;
 import google.registry.monitoring.blackbox.exceptions.UndeterminedStateException;
 import google.registry.monitoring.blackbox.messages.OutboundMessageType;
 import google.registry.monitoring.blackbox.tokens.Token;
 import io.netty.bootstrap.Bootstrap;
-import io.netty.channel.ChannelFuture;
-import java.util.function.Consumer;
 import org.joda.time.Duration;
 
 /**
@@ -34,15 +31,7 @@
  * Token} and from that, generates a new {@link ProbingAction} to call.</p>
  */
 @AutoValue
-public abstract class ProbingStep implements Consumer<Token> {
-
-  private static final FluentLogger logger = FluentLogger.forEnclosingClass();
-
-  /**
-   * Necessary boolean to inform when to obtain next {@link Token}
-   */
-  protected boolean isLastStep = false;
-  private ProbingStep nextStep;
+public abstract class ProbingStep {
 
   public static Builder builder() {
     return new AutoValue_ProbingStep.Builder();
@@ -69,22 +58,10 @@ public static Builder builder() {
    */
   abstract Bootstrap bootstrap();
 
-  void lastStep() {
-    isLastStep = true;
-  }
-
-  void nextStep(ProbingStep step) {
-    this.nextStep = step;
-  }
-
-  ProbingStep nextStep() {
-    return this.nextStep;
-  }
-
   /**
    * Generates a new {@link ProbingAction} from {@code token} modified {@link OutboundMessageType}
    */
-  private ProbingAction generateAction(Token token) throws UndeterminedStateException {
+  public ProbingAction generateAction(Token token) throws UndeterminedStateException {
     OutboundMessageType message = token.modifyMessage(messageTemplate());
     ProbingAction.Builder probingActionBuilder = ProbingAction.builder()
         .setDelay(duration())
@@ -101,71 +78,6 @@ private ProbingAction generateAction(Token token) throws UndeterminedStateExcept
     return probingActionBuilder.build();
   }
 
-  /**
-   * On the last step, gets the next {@link Token}. Otherwise, uses the same one.
-   */
-  private Token generateNextToken(Token token) {
-    return isLastStep ? token.next() : token;
-  }
-
-  /**
-   * Generates new {@link ProbingAction}, calls the action, then retrieves the result of the
-   * action.
-   *
-   * @param token - used to generate the {@link ProbingAction} by calling {@code generateAction}.
-   *
-   * <p>If unable to generate the action, or the calling the action results in an immediate error,
-   * we note an error. Otherwise, if the future marked as finished when the action is completed is
-   * marked as a success, we note a success. Otherwise, if the cause of failure will either be a
-   * failure or error. </p>
-   */
-  @Override
-  public void accept(Token token) {
-    ProbingAction currentAction;
-    //attempt to generate new action. On error, move on to next step
-    try {
-      currentAction = generateAction(token);
-    } catch (UndeterminedStateException e) {
-      logger.atWarning().withCause(e).log("Error in Action Generation");
-      nextStep.accept(generateNextToken(token));
-      return;
-    }
-
-    ChannelFuture future;
-    try {
-      //call the generated action
-      future = currentAction.call();
-    } catch (Exception e) {
-      //On error in calling action, log error and note an error
-      logger.atWarning().withCause(e).log("Error in Action Performed");
-
-      //Move on to next step in ProbingSequence
-      nextStep.accept(generateNextToken(token));
-      return;
-    }
-
-    future.addListener(f -> {
-      if (f.isSuccess()) {
-        //On a successful result, we log as a successful step, and not a success
-        logger.atInfo().log(String.format("Successfully completed Probing Step: %s", this));
-
-      } else {
-        //On a failed result, we log the failure and note either a failure or error
-        logger.atSevere().withCause(f.cause()).log("Did not result in future success");
-      }
-
-      if (protocol().persistentConnection()) {
-        //If the connection is persistent, we store the channel in the token
-        token.setChannel(currentAction.channel());
-      }
-
-      //Move on the the next step in the ProbingSequence
-      nextStep.accept(generateNextToken(token));
-
-
-    });
-  }
-
   @Override
   public final String toString() {
     return String.format("ProbingStep with Protocol: %s\n"
@@ -174,9 +86,7 @@ public final String toString() {
         messageTemplate().getClass().getName());
   }
 
-  /**
-   * Default {@link AutoValue.Builder} for {@link ProbingStep}.
-   */
+  /** Standard {@link AutoValue.Builder} for {@link ProbingStep}. */
   @AutoValue.Builder
   public abstract static class Builder {
 
@@ -193,4 +103,3 @@ public abstract static class Builder {
 
 }
 
-

prober/src/main/java/google/registry/monitoring/blackbox/WebWhoisModule.java

@@ -23,6 +23,7 @@
 import google.registry.monitoring.blackbox.handlers.WebWhoisMessageHandler;
 import google.registry.monitoring.blackbox.messages.HttpRequestMessage;
 import google.registry.monitoring.blackbox.tokens.WebWhoisToken;
+import google.registry.util.DefaultCircularLinkedListIterator;
 import io.netty.bootstrap.Bootstrap;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandler;
@@ -31,6 +32,7 @@
 import io.netty.handler.codec.http.HttpClientCodec;
 import io.netty.handler.codec.http.HttpObjectAggregator;
 import io.netty.handler.ssl.SslProvider;
+import java.util.Iterator;
 import javax.inject.Provider;
 import javax.inject.Qualifier;
 import javax.inject.Singleton;
@@ -121,7 +123,6 @@ static ImmutableList<Provider<? extends ChannelHandler>> providerHttpWhoisHandle
         messageHandlerProvider,
         webWhoisActionHandlerProvider);
   }
-
   /**
    * {@link Provides} the list of providers of {@link ChannelHandler}s that are used for https
    * protocol.
@@ -188,7 +189,7 @@ ProbingSequence provideWebWhoisSequence(
       WebWhoisToken webWhoisToken) {
 
     return new ProbingSequence.Builder(webWhoisToken)
-        .addStep(probingStep)
+        .addElement(probingStep)
         .build();
   }
 
@@ -204,8 +205,10 @@ int provideMaximumMessageLengthBytes() {
   @Singleton
   @Provides
   @WebWhoisProtocol
-  ImmutableList<String> provideTopLevelDomains() {
-    return ImmutableList.of("how", "soy", "xn--q9jyb4c");
+  Iterator<String> provideTopLevelDomains() {
+    return new DefaultCircularLinkedListIterator.Builder<String>()
+        .addElements("how", "soy", "xn--q9jyb4c")
+        .build();
   }
 
   @Provides
@@ -243,6 +246,5 @@ int provideHttpsWhoisPort() {
   public @interface WebWhoisProtocol {
 
   }
-
-
 }
+