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 305 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;
     }
   }
 }