[logdog-stream-view] Fix loading loop.

web/inc/logdog-stream-view/model.ts

 /*
   Copyright 2016 The LUCI Authors. All rights reserved.
   Use of this source code is governed under the Apache License, Version 2.0
   that can be found in the LICENSE file.
 */
 
 ///<reference path="../logdog-stream/logdog.ts" />
 ///<reference path="../luci-operation/operation.ts" />
 ///<reference path="../luci-sleep-promise/promise.ts" />
 ///<reference path="../rpc/client.ts" />
@@ skipping 312 matching lines @@
       this.clearCurrentOperation();
       this.provider = this.nullProvider();
 
       this.updateControls();
     }
 
     private nullProvider(): LogProvider {
       return new AggregateLogStream([]);
     }
 
-    private clearCurrentOperation() {
+    /**
+     * Clears the current operation, cancelling it if set. If the operation is
+     * cleared, the current fetch and rendering states will be reset.
+     *
+     * @param op if provided, only cancel the current operation if it equals
+     *     the supplied "op". If "op" does not match the current operation, it
+     *     will be cancelled, but the current operation will be left in-tact.
+     *     If "op" is undefined, cancel the current operation regardless.
+     */
+    private clearCurrentOperation(op?: luci.Operation) {
       if (this.currentOperation) {
+        if (op && op !== this.currentOperation) {
+          // Conditional clear, and we are not the current operation, so do
+          // nothing.
+          op.cancel();
+          return;
+        }
         this.currentOperation.cancel();
         this.currentOperation = this.currentFetchPromise = null;
       }
       this.rendering = false;
     }
 
     private get loadingState(): LoadingState {
       return this.loadingStateValue;
     }
     private set loadingState(v: LoadingState) {
@@ skipping 91 matching lines @@
       // We're not split. If we haven't reached end of stream, fetch logs from
       // HEAD.
       return this.fetchLocation(Location.HEAD, cancel);
     }
 
     /** Fetch logs from an explicit location. */
     async fetchLocation(l: Location, cancel: boolean): Promise<void> {
       if (this.currentFetchPromise && (!cancel)) {
         return this.currentFetchPromise;
       }
+      this.clearCurrentOperation();
 
       // If our provider is finished, then do nothing.
       if (this.fetchedFullStream) {
         // There are no more logs.
         return undefined;
       }
 
       // If we're asked to fetch BOTTOM, but we're not split, fetch HEAD
       // instead.
       if (l === Location.BOTTOM && !this.isSplit) {
         l = Location.HEAD;
       }
 
-      // If we're not split, always fetch from BOTTOM.
-      this.loadingState = LoadingState.LOADING;
-      let loadingWhileTimer =
-          new luci.Timer(Model.LOADING_WHILE_THRESHOLD_MS, () => {
-            if (this.loadingState === LoadingState.LOADING) {
-              this.loadingState = LoadingState.LOADING_BEEN_A_WHILE;
-            }
-          });
-
       // Rotate our fetch ID. This will effectively cancel any pending fetches.
       this.currentOperation = new luci.Operation();
       this.currentFetchPromise =
           this.fetchLocationImpl(l, this.currentOperation);
-      try {
-        await this.currentFetchPromise;
-      } catch (err) {
-        loadingWhileTimer.cancel();
-
-        // If we've been canceled, discard this result.
-        if (err === luci.Operation.CANCELLED) {
-          return;
-        }
-
-        this.clearCurrentOperation();
-        if (err === NOT_AUTHENTICATED) {
-          this.loadingState = LoadingState.NEEDS_AUTH;
-
-          // We failed because we were not authenticated. Mark this
-          // so we can retry if that state changes.
-          await this.authChangedPromise;
-
-          // Our authentication state changed during the fetch!
-          // Retry automatically.
-          return this.fetchLocation(l, false);
-        }
-
-        console.error('Failed to load log streams:', err);
-      };
-
-      loadingWhileTimer.cancel();
       return this.currentFetchPromise;
     }
 
     private async fetchLocationImpl(l: Location, op: luci.Operation) {
+      for (let continueFetching = true; continueFetching;) {
+        this.loadingState = LoadingState.LOADING;
+
+        let loadingWhileTimer =
+            new luci.Timer(Model.LOADING_WHILE_THRESHOLD_MS, () => {
+              if (this.loadingState === LoadingState.LOADING) {
+                this.loadingState = LoadingState.LOADING_BEEN_A_WHILE;
+              }
+            });
+
+        let hasLogs = false;
+        try {
+          hasLogs = await this.fetchLocationRound(l, op);
+        } catch (err) {
+          // Cancel the timer here, since we may enter other states in this
+          // "catch" block and we don't want to have the timer override them.
+          loadingWhileTimer.cancel();
+
+          // If we've been canceled, discard this result.
+          if (err === luci.Operation.CANCELLED) {
+            return;
+          }
+
+          this.clearCurrentOperation(op);
+          if (err === NOT_AUTHENTICATED) {
+            this.loadingState = LoadingState.NEEDS_AUTH;
+
+            // We failed because we were not authenticated. Mark this
+            // so we can retry if that state changes.
+            await this.authChangedPromise;
+
+            // Our authentication state changed during the fetch!
+            // Retry automatically.
+            continueFetching = true;
+            continue;
+          }
+
+          console.error('Failed to load log streams:', err);
+          return;
+        } finally {
+          loadingWhileTimer.cancel();
+        }
+
+        continueFetching = (this.automatic && hasLogs);
+        if (continueFetching) {
+          console.log('Automatic: starting next fetch.');
+        }
+      }
+
+      // Post-fetch cleanup.
+      this.clearCurrentOperation(op);
+    }
+
+    private async fetchLocationRound(l: Location, op: luci.Operation) {
       let buf = await this.provider.fetch(op, l);
 
       // Clear our fetching status.
       this.rendering = true;
       this.loadingState = LoadingState.RENDERING;
-      let hasLogs = (buf && buf.peek());
+      let hasLogs = !!(buf && buf.peek());
 
       // Resolve any previous rendering Promise that we have. This
       // makes sure our rendering and fetching don't get more than
       // one round out of sync.
       if (this.renderPromise) {
         await this.renderPromise;
       }
-      // Post-fetch cleanup.
-      this.clearCurrentOperation();
 
       // Clear our loading state (updates controls automatically).
       this.loadingState = LoadingState.RENDERING;
 
       // Initiate the next render. This will happen in the
       // background while we enqueue our next fetch.
       let doRender = async () => {
         await this.renderLogs(buf, l);
         if (this.loadingState === LoadingState.RENDERING) {
           this.loadingState = LoadingState.NONE;
         }
       };
       this.renderPromise = doRender();
 
       if (this.fetchedFullStream) {
-        return;
+        return false;
       }
-
-      // The fetch is finished. If we're automatic, and we got logs, start the
-      // next fetch.
-      if (this.automatic && hasLogs) {
-        console.log('Automatic: starting next fetch.');
-        return this.fetch(false);
-      }
+      return hasLogs;
     }
 
     private async renderLogs(buf: BufferedLogs, l: Location) {
       if (!(buf && buf.peek())) {
         return;
       }
 
       let logBlock: LogDog.LogEntry[] = [];
 
       // Create a promise loop to push logs at intervals.
@@ skipping 161 matching lines @@
 
     /** The size of the tail walkback region. */
     private static TAIL_WALKBACK = 500;
 
     constructor(
         client: LogDog.Client, readonly stream: LogDog.StreamPath,
         readonly initialFetchSize: number, readonly fetchSize: number) {
       this.fetcher = new LogDog.Fetcher(client, stream);
     }
 
-    private clearActiveFetch() {
-      if (this.activeFetch) {
-        this.activeFetch.op.cancel();
-      }
-    }
-
     private setActiveFetch(fetch: LogDog.Fetch): LogDog.Fetch {
-      this.clearActiveFetch();
       this.activeFetch = fetch;
       this.activeFetch.addStateChangedCallback((_: LogDog.Fetch) => {
         this.statusChanged();
       });
       return fetch;
     }
 
     get fetchStatus(): LogDog.FetchStatus {
       if (this.activeFetch) {
         return this.activeFetch.lastStatus;
       }
       return LogDog.FetchStatus.IDLE;
     }
 
     get fetchError(): Error|undefined {
       if (this.activeFetch) {
         return this.activeFetch.lastError;
       }
       return undefined;
     }
 
     async fetch(op: luci.Operation, l: Location) {
-      this.clearActiveFetch();
-
       // Determine which method to use based on the insertion point and current
       // log stream fetch state.
       let getLogs: Promise<LogDog.LogEntry[]>;
       switch (l) {
         case Location.HEAD:
           getLogs = this.getHead(op);
           break;
 
         case Location.TAIL:
           getLogs = this.getTail(op);
@@ skipping 662 matching lines @@
 
       // Get the next log and increment our index.
       let log = this.logs[this.index++];
       if (this.index >= this.logs.length) {
         this.logs = null;
       }
       return log;
     }
   }
 }