microsoft · joyceerhl · Nov 25, 2020 · Nov 16, 2020 · Nov 17, 2020 · Nov 17, 2020
diff --git a/news/1 Enhancements/14807.md b/news/1 Enhancements/14807.md
@@ -0,0 +1 @@
+Detect tfevent files in workspace and prompt to launch native TensorBoard session.
diff --git a/package.nls.json b/package.nls.json
@@ -222,9 +222,9 @@
     "StartPage.badWebPanelFormatString": "<html><body><h1>{0} is not a valid file name</h1></body></html>",
     "Jupyter.extensionRequired": "The Jupyter extension is required to perform that task. Click Yes to open the Jupyter extension installation page.",
     "TensorBoard.logDirectoryPrompt" : "Please select a log directory to start TensorBoard with.",
-	"TensorBoard.installPrompt" : "The package TensorBoard is required in order to launch a TensorBoard session. Would you like to install it?",
-	"TensorBoard.failedToStartSessionError" : "We failed to start a TensorBoard session due to the following error: {0}",
     "TensorBoard.progressMessage" : "Starting TensorBoard session...",
+	"TensorBoard.failedToStartSessionError" : "We failed to start a TensorBoard session due to the following error: {0}",
+    "TensorBoard.nativeTensorBoardPrompt" : "VS Code now has native TensorBoard support. Would you like to launch TensorBoard?",
     "TensorBoard.usingCurrentWorkspaceFolder": "We are using the current workspace folder as the log directory for your TensorBoard session.",
     "TensorBoard.selectAFolder": "Select a folder"
 }
diff --git a/src/client/common/application/types.ts b/src/client/common/application/types.ts
@@ -795,7 +795,8 @@ export interface IWorkspaceService {
      * will be matched against the file paths of resulting matches relative to their workspace. Use a [relative pattern](#RelativePattern)
      * to restrict the search results to a [workspace folder](#WorkspaceFolder).
      * @param exclude  A [glob pattern](#GlobPattern) that defines files and folders to exclude. The glob pattern
-     * will be matched against the file paths of resulting matches relative to their workspace.
+     * will be matched against the file paths of resulting matches relative to their workspace. If `undefined` is passed,
+     * the glob patterns excluded in the `search.exclude` setting will be applied.
      * @param maxResults An upper-bound for the result.
      * @param token A token that can be used to signal cancellation to the underlying search engine.
      * @return A thenable that resolves to an array of resource identifiers. Will return no results if no

diff --git a/src/client/common/application/workspace.ts b/src/client/common/application/workspace.ts
@@ -52,13 +52,13 @@ export class WorkspaceService implements IWorkspaceService {
     }
     public createFileSystemWatcher(
         globPattern: GlobPattern,
-        _ignoreCreateEvents?: boolean,
+        ignoreCreateEvents?: boolean,
         ignoreChangeEvents?: boolean,
         ignoreDeleteEvents?: boolean
     ): FileSystemWatcher {
         return workspace.createFileSystemWatcher(
             globPattern,
-            ignoreChangeEvents,
+            ignoreCreateEvents,
             ignoreChangeEvents,
             ignoreDeleteEvents
         );
@@ -69,7 +69,8 @@ export class WorkspaceService implements IWorkspaceService {
         maxResults?: number,
         token?: CancellationToken
     ): Thenable<Uri[]> {
-        return workspace.findFiles(include, exclude, maxResults, token);
+        const excludePattern = exclude === undefined ? this.searchExcludes : exclude;
+        return workspace.findFiles(include, excludePattern, maxResults, token);
     }
     public getWorkspaceFolderIdentifier(resource: Resource, defaultValue: string = ''): string {
         const workspaceFolder = resource ? workspace.getWorkspaceFolder(resource) : undefined;
@@ -79,4 +80,10 @@ export class WorkspaceService implements IWorkspaceService {
               )
             : defaultValue;
     }
+
+    private get searchExcludes() {
+        const searchExcludes = this.getConfiguration('search.exclude');
+        const enabledSearchExcludes = Object.keys(searchExcludes).filter((key) => searchExcludes.get(key) === true);
+        return `{${enabledSearchExcludes.join(',')}}`;
+    }
 }
diff --git a/src/client/common/utils/localize.ts b/src/client/common/utils/localize.ts
@@ -139,14 +139,14 @@ export namespace TensorBoard {
         'Please select a log directory to start TensorBoard with.'
     );
     export const progressMessage = localize('TensorBoard.progressMessage', 'Starting TensorBoard session...');
-    export const installTensorBoardPrompt = localize(
-        'TensorBoard.installPrompt',
-        'The package TensorBoard is required in order to launch a TensorBoard session. Would you like to install it?'
-    );
     export const failedToStartSessionError = localize(
         'TensorBoard.failedToStartSessionError',
         'We failed to start a TensorBoard session due to the following error: {0}'
     );
+    export const nativeTensorBoardPrompt = localize(
+        'TensorBoard.nativeTensorBoardPrompt',
+        'VS Code now has native TensorBoard support. Would you like to launch TensorBoard?'
+    );
     export const usingCurrentWorkspaceFolder = localize(
         'TensorBoard.usingCurrentWorkspaceFolder',
         'We are using the current workspace folder as the log directory for your TensorBoard session.'

diff --git a/src/client/tensorBoard/serviceRegistry.ts b/src/client/tensorBoard/serviceRegistry.ts
@@ -3,11 +3,18 @@
 
 import { IExtensionSingleActivationService } from '../activation/types';
 import { IServiceManager } from '../ioc/types';
+import { TensorBoardFileWatcher } from './tensorBoardFileWatcher';
+import { TensorBoardPrompt } from './tensorBoardPrompt';
 import { TensorBoardSessionProvider } from './tensorBoardSessionProvider';
 
 export function registerTypes(serviceManager: IServiceManager) {
     serviceManager.addSingleton<IExtensionSingleActivationService>(
         IExtensionSingleActivationService,
         TensorBoardSessionProvider
     );
+    serviceManager.addSingleton<IExtensionSingleActivationService>(
+        IExtensionSingleActivationService,
+        TensorBoardFileWatcher
+    );
+    serviceManager.addSingleton<TensorBoardPrompt>(TensorBoardPrompt, TensorBoardPrompt);
 }
diff --git a/src/client/tensorBoard/tensorBoardFileWatcher.ts b/src/client/tensorBoard/tensorBoardFileWatcher.ts
@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { inject, injectable } from 'inversify';
+import { FileSystemWatcher, RelativePattern, WorkspaceFolder, WorkspaceFoldersChangeEvent } from 'vscode';
+import { IExtensionSingleActivationService } from '../activation/types';
+import { IWorkspaceService } from '../common/application/types';
+import { NativeTensorBoard } from '../common/experiments/groups';
+import { traceError } from '../common/logger';
+import { IDisposableRegistry, IExperimentService } from '../common/types';
+import { TensorBoardPrompt } from './tensorBoardPrompt';
+
+@injectable()
+export class TensorBoardFileWatcher implements IExtensionSingleActivationService {
+    private fileSystemWatchers = new Map<WorkspaceFolder, FileSystemWatcher[]>();
+    private globPattern1 = '*tfevents*';
+    private globPattern2 = '*/*tfevents*';
+
+    constructor(
+        @inject(IWorkspaceService) private workspaceService: IWorkspaceService,
+        @inject(TensorBoardPrompt) private tensorBoardPrompt: TensorBoardPrompt,
+        @inject(IDisposableRegistry) private readonly disposables: IDisposableRegistry,
+        @inject(IExperimentService) private experimentService: IExperimentService
+    ) {}
+
+    public async activate() {
+        if (!(await this.experimentService.inExperiment(NativeTensorBoard.experiment))) {
+            return;
+        }
+
+        const folders = this.workspaceService.workspaceFolders;
+        if (!folders) {
+            return;
+        }
+
+        // Look for pre-existing tfevent files, as the file watchers will only pick up files
+        // created or changed after they have been registered and hooked up. Just one will do.
+        await this.promptIfWorkspaceHasPreexistingFiles();
+
+        // If the user creates or changes tfevent files, listen for those too
+        for (const folder of folders) {
+            this.createFileSystemWatcher(folder);
+        }
+
+        // If workspace folders change, ensure we update our FileSystemWatchers
+        this.disposables.push(
+            this.workspaceService.onDidChangeWorkspaceFolders((e) => this.updateFileSystemWatchers(e))
+        );
+    }
+
+    private async promptIfWorkspaceHasPreexistingFiles() {
+        try {
+            for (const pattern of [this.globPattern1, this.globPattern2]) {
+                const matches = await this.workspaceService.findFiles(pattern, undefined, 1);
+                if (matches.length > 0) {
+                    await this.tensorBoardPrompt.showNativeTensorBoardPrompt();
+                    return;
+                }
+            }
+        } catch (e) {
+            traceError(
+                `Failed to prompt to launch TensorBoard session based on preexisting tfevent files in workspace: ${e}`
+            );
+        }
+    }
+
+    private async updateFileSystemWatchers(event: WorkspaceFoldersChangeEvent) {
+        for (const added of event.added) {
+            this.createFileSystemWatcher(added);
+        }
+        for (const removed of event.removed) {
+            const fileSystemWatchers = this.fileSystemWatchers.get(removed);
+            if (fileSystemWatchers) {
+                fileSystemWatchers.forEach((fileWatcher) => fileWatcher.dispose());
+                this.fileSystemWatchers.delete(removed);
+            }
+        }
+    }
+
+    private createFileSystemWatcher(folder: WorkspaceFolder) {
+        const fileWatchers = [];
+        for (const pattern of [this.globPattern1, this.globPattern2]) {
+            const relativePattern = new RelativePattern(folder, pattern);
+            const fileSystemWatcher = this.workspaceService.createFileSystemWatcher(relativePattern);
+
+            // When a file is created or changed that matches `this.globPattern`, try to show our prompt
+            this.disposables.push(
+                fileSystemWatcher.onDidCreate((_uri) => this.tensorBoardPrompt.showNativeTensorBoardPrompt())
+            );
+            this.disposables.push(
+                fileSystemWatcher.onDidChange((_uri) => this.tensorBoardPrompt.showNativeTensorBoardPrompt())
+            );
+            this.disposables.push(fileSystemWatcher);
+            fileWatchers.push(fileSystemWatcher);
+        }
+        this.fileSystemWatchers.set(folder, fileWatchers);
+    }
+}
diff --git a/src/client/tensorBoard/tensorBoardPrompt.ts b/src/client/tensorBoard/tensorBoardPrompt.ts
@@ -0,0 +1,65 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { inject, injectable } from 'inversify';
+import { IApplicationShell, ICommandManager } from '../common/application/types';
+import { Commands } from '../common/constants';
+import { IPersistentState, IPersistentStateFactory } from '../common/types';
+import { Common, TensorBoard } from '../common/utils/localize';
+
+enum TensorBoardPromptStateKeys {
+    ShowNativeTensorBoardPrompt = 'showNativeTensorBoardPrompt'
+}
+
+@injectable()
+export class TensorBoardPrompt {
+    private state: IPersistentState<boolean>;
+    private enabled: Promise<boolean> | undefined;
+    private waitingForUserSelection: boolean = false;
+
+    constructor(
+        @inject(IApplicationShell) private applicationShell: IApplicationShell,
+        @inject(ICommandManager) private commandManager: ICommandManager,
+        @inject(IPersistentStateFactory) private persistentStateFactory: IPersistentStateFactory
+    ) {
+        this.state = this.persistentStateFactory.createWorkspacePersistentState<boolean>(
+            TensorBoardPromptStateKeys.ShowNativeTensorBoardPrompt,
+            true
+        );
+        this.enabled = this.isPromptEnabled();
+    }
+
+    public async showNativeTensorBoardPrompt() {
+        if ((await this.enabled) && !this.waitingForUserSelection) {
+            const yes = Common.bannerLabelYes();
+            const no = Common.bannerLabelNo();
+            const doNotAskAgain = Common.doNotShowAgain();
+            const options = [yes, no, doNotAskAgain];
+            this.waitingForUserSelection = true;
+            const selection = await this.applicationShell.showInformationMessage(
+                TensorBoard.nativeTensorBoardPrompt(),
+                ...options
+            );
+            this.waitingForUserSelection = false;
+            switch (selection) {
+                case yes:
+                    await this.commandManager.executeCommand(Commands.LaunchTensorBoard);
+                    await this.disablePrompt();
+                    break;
+                case doNotAskAgain:
+                    await this.disablePrompt();
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    private async isPromptEnabled() {
+        return this.state.value;
+    }
+
+    private async disablePrompt() {
+        await this.state.updateValue(false);
+    }
+}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		Detect tfevent files in workspace and prompt to launch native TensorBoard session.