LogDog Viewer: Link back to source build.

web/inc/logdog-stream-view/viewer.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 174 matching lines @@
     private currentOperation: luci.Operation|null = null;
     private currentFetchPromise: Promise<void>|null = null;
 
     /** Are we in automatic mode? */
     private automatic = false;
     /** Are we tailing? */
     private fetchFromTail = false;
     /** Are we in the middle of rendering logs? */
     private rendering = true;
 
+    private cachedLogStreamUrl: string|undefined = undefined;
+
     private loadingStateValue: LoadingState = LoadingState.NONE;
     private streamStatusValue: StreamStatusEntry[];
 
     /**
      * When rendering a Promise that will resolve when the render completes. We
      * use this to pipeline parallel data fetching and rendering.
      */
     private renderPromise: Promise<void>|null;
 
     constructor(
@@ skipping 142 matching lines @@
       this.streamStatusValue = st;
       this.updateControls();
     }
 
     private updateControls() {
       this.view.updateControls({
         canSplit: this.providerCanSplit,
         split: this.isSplit,
         bottom: !this.fetchedEndOfStream,
         fullyLoaded: (this.fetchedFullStream && (!this.rendering)),
+        logStreamUrl: this.logStreamUrl,
         loadingState: this.loadingState,
         streamStatus: this.streamStatus,
       });
     }
 
     /**
      * Note that the authentication state for the client has changed. This will
      * trigger an automatic fetch retry if our previous fetch failed due to
      * lack of authentication.
      */
@@ skipping 258 matching lines @@
       return (!!(split && split.isSplit()));
     }
 
     private get fetchedEndOfStream(): boolean {
       return (this.provider.fetchedEndOfStream());
     }
 
     private get fetchedFullStream(): boolean {
       return (this.fetchedEndOfStream && (!this.isSplit));
     }
+
+    private get logStreamUrl(): string|undefined {
+      if (!this.cachedLogStreamUrl) {
+        this.cachedLogStreamUrl = this.provider.getLogStreamUrl();
+      }
+      return this.cachedLogStreamUrl;
+    }
   }
 
   /** Generic interface for a log provider. */
   interface LogProvider {
     setStreamStatusCallback(cb: StreamStatusCallback): void;
     fetch(op: luci.Operation, l: Location): Promise<BufferedLogs>;
+    getLogStreamUrl(): string|undefined;
 
     /** Will return null if this LogProvider doesn't support splitting. */
     split(): SplitLogProvider|null;
     fetchedEndOfStream(): boolean;
   }
 
   /** Additional methods for log stream splitting, if supported. */
   interface SplitLogProvider {
     canSplit(): boolean;
     isSplit(): boolean;
@@ skipping 90 matching lines @@
       try {
         let logs = await getLogs;
         this.initialFetch = false;
         this.statusChanged();
         return new BufferedLogs(logs);
       } catch (err) {
         throw resolveErr(err);
       }
     }
 
+    get descriptor() {
+      return this.fetcher.desc;
+    }
+
+    getLogStreamUrl(): string|undefined {
+      let desc = this.descriptor;
+      if (desc) {
+        return (desc.tags || {})['logdog.viewer_url'];
+      }
+      return undefined;
+    }
+
     setStreamStatusCallback(cb: StreamStatusCallback) {
       this.streamStatusCallback = cb;
     }
 
     private statusChanged() {
       if (this.streamStatusCallback) {
         this.streamStatusCallback([this.getStreamStatus()]);
       }
     }
 
@@ skipping 232 matching lines @@
    * entries can be yielded, since we don't know what ordering to apply
    * otherwise.  To make this fast, we will make the first request for each
    * stream small so it finishes quickly and we can start rendering. Subsequent
    * entries will be larger for efficiency.
    *
    * @param {LogStream} streams the composite streams.
    */
   class AggregateLogStream implements LogProvider {
     private streams: AggregateLogStream.Entry[];
     private active: AggregateLogStream.Entry[];
+    private sharedPrefix: boolean;
     private currentNextPromise: Promise<BufferedLogs[]>|null;
     private compareLogs: (a: LogDog.LogEntry, b: LogDog.LogEntry) => number;
 
     private streamStatusCallback: StreamStatusCallback;
 
     constructor(streams: LogStream[]) {
       // Input streams, ordered by input order.
       this.streams = streams.map<AggregateLogStream.Entry>((ls, i) => {
         ls.setStreamStatusCallback((st: LogStreamStatus[]) => {
           if (st) {
             this.streams[i].status = st[0];
             this.statusChanged();
           }
         });
 
         return new AggregateLogStream.Entry(ls);
       });
 
       // Subset of input streams that are still active (not finished).
       this.active = this.streams;
 
       // The currently-active "next" promise.
       this.currentNextPromise = null;
 
       // Determine our log comparison function. If all of our logs share a
       // prefix, we will use the prefix index. Otherwise, we will use the
       // timestamp.
       let template: LogDog.StreamPath;
-      let sharedPrefix = this.streams.every((entry) => {
+      this.sharedPrefix = this.streams.every((entry) => {

[nodir, 2017/05/03 15:36:52]

I don't think this is used outside of this function, so posdibly this field is
unnecessary?

[dnj, 2017/05/03 15:40:43]

Correct, I originally wanted to only return links for aggregate streams with a
shared prefix but then I decided that any link is better than none, so just do
it everywhere. Removed.

         if (!template) {
           template = entry.ls.stream;
           return true;
         }
         return template.samePrefixAs(entry.ls.stream);
       });
 
-      this.compareLogs = ((sharedPrefix) ? (a, b) => {
+      this.compareLogs = ((this.sharedPrefix) ? (a, b) => {
         return (a.prefixIndex - b.prefixIndex);
       } : (a, b) => {
         if (a.timestamp) {
           if (b.timestamp) {
             return a.timestamp.getTime() - b.timestamp.getTime();
           }
           return 1;
         } else if (b.timestamp) {
           return -1;
         } else {
@@ skipping 16 matching lines @@
     private statusChanged() {
       if (this.streamStatusCallback) {
         // Iterate through our composite stream statuses and pick the one that
         // we want to report.
         this.streamStatusCallback(this.streams.map((entry): LogStreamStatus => {
           return entry.status;
         }));
       }
     }
 
+    getLogStreamUrl(): string|undefined {
+      // Return the first log stream viewer URL. IF we have a shared prefix,
+      // this will always work. Otherwise, returning something is better than
+      // nothing, so if any of the base streams have a URL, we will return it.
+      for (let s of this.streams) {
+        let url = s.ls.getLogStreamUrl();
+        if (url) {
+          return url;
+        }
+      }
+      return undefined;
+    }
+
     /**
      * Implements LogProvider.next
      */
     async fetch(op: luci.Operation, _: Location) {
       // If we're already are fetching the next buffer, this is an error.
       if (this.currentNextPromise) {
         throw new Error('In-progress next(), cannot start another.');
       }
 
       // Filter out any finished streams from our active list. A stream is
@@ skipping 209 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;
     }
   }
 }