Add file watcher for .databricks/project.json (#84)

Closes #50

Author: kartikgupta-db

packages/databricks-vscode/src/configuration/ConnectionManager.ts

@@ -98,12 +98,6 @@ export class ConnectionManager {
         let profile;
 
         try {
-            if (!vscodeWorkspace.rootPath) {
-                throw new Error(
-                    "Can't login to Databricks: Not in a VSCode workspace"
-                );
-            }
-
             projectConfigFile = await ProjectConfigFile.load(
                 vscodeWorkspace.rootPath
             );
@@ -173,7 +167,7 @@ export class ConnectionManager {
     }
 
     async configureProject() {
-        let profile;
+        let profile: string | undefined;
         while (true) {
             profile = await selectProfile(this.cli);
             if (!profile) {
@@ -200,7 +194,7 @@ export class ConnectionManager {
 
                     case "Open configuration file":
                         await commands.executeCommand(
-                            "databricks.openDatabricksConfigFile"
+                            "databricks.connection.openDatabricksConfigFile"
                         );
                         return;
                 }
@@ -216,10 +210,6 @@ export class ConnectionManager {
     }
 
     private async writeConfigFile(profile: string) {
-        if (!vscodeWorkspace.rootPath) {
-            throw new Error("Not in a VSCode workspace");
-        }
-
         const projectConfigFile = new ProjectConfigFile(
             {},
             vscodeWorkspace.rootPath

packages/databricks-vscode/src/configuration/ProjectConfigFile.test.ts

@@ -0,0 +1,42 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import {Disposable, Uri, workspace} from "vscode";
+import {CliWrapper} from "../cli/CliWrapper";
+import {mkdtemp, readFile} from "fs/promises";
+import {ProjectConfigFile} from "./ProjectConfigFile";
+import * as assert from "assert";
+import path from "path";
+import * as os from "os";
+
+describe(__filename, () => {
+    let tempDir: string;
+    before(async () => {
+        tempDir = await mkdtemp(path.join(os.tmpdir(), "ProjectConfTests-"));
+    });
+
+    it("should write config file", async () => {
+        const expected = {
+            clusterId: "testClusterId",
+            profile: "testProfile",
+            workspacePath: "workspacePath",
+        };
+        await new ProjectConfigFile(expected, tempDir).write();
+
+        const rawData = await readFile(
+            ProjectConfigFile.getProjectConfigFilePath(tempDir),
+            {encoding: "utf-8"}
+        );
+        const actual = JSON.parse(rawData);
+        assert.deepEqual(actual, expected);
+    });
+
+    it("should load config file", async () => {
+        const expected = {
+            clusterId: "testClusterId",
+            profile: "testProfile",
+            workspacePath: "workspacePath",
+        };
+        const actual = await ProjectConfigFile.load(tempDir);
+        assert.deepEqual(actual.config, expected);
+    });
+});

packages/databricks-vscode/src/configuration/ProjectConfigFile.ts

@@ -10,23 +10,45 @@ export interface ProjectConfig {
 export class ConfigFileError extends Error {}
 
 export class ProjectConfigFile {
-    constructor(public config: ProjectConfig, private projectDir: string) {}
+    constructor(public config: ProjectConfig, readonly rootPath?: string) {}
+
+    get profile() {
+        return this.config.profile;
+    }
 
     set profile(profile: string | undefined) {
         this.config.profile = profile;
     }
 
+    get clusterId() {
+        return this.config.clusterId;
+    }
+
     set clusterId(clusterId: string | undefined) {
         this.config.clusterId = clusterId;
     }
 
+    get workspacePath() {
+        return this.config.workspacePath;
+    }
+
     set workspacePath(workspacePath: string | undefined) {
         this.config.workspacePath = workspacePath;
     }
 
     async write() {
+        try {
+            const originalConfig = await ProjectConfigFile.load(this.rootPath);
+            if (
+                JSON.stringify(originalConfig.config, null, 2) ===
+                JSON.stringify(this.config, null, 2)
+            ) {
+                return;
+            }
+        } catch (e) {}
+
         let fileName = ProjectConfigFile.getProjectConfigFilePath(
-            this.projectDir
+            this.rootPath
         );
         await fs.mkdir(path.dirname(fileName), {recursive: true});
 
@@ -35,8 +57,8 @@ export class ProjectConfigFile {
         });
     }
 
-    static async load(projectDir: string): Promise<ProjectConfigFile> {
-        const projectConfigFilePath = this.getProjectConfigFilePath(projectDir);
+    static async load(rootPath?: string): Promise<ProjectConfigFile> {
+        const projectConfigFilePath = this.getProjectConfigFilePath(rootPath);
 
         let rawConfig;
         try {
@@ -60,11 +82,14 @@ export class ProjectConfigFile {
             throw new ConfigFileError("Error parsing project config file");
         }
 
-        return new ProjectConfigFile(config, projectDir);
+        return new ProjectConfigFile(config, rootPath);
     }
 
-    private static getProjectConfigFilePath(projectDir: string): string {
-        let cwd = path.normalize(projectDir);
+    static getProjectConfigFilePath(rootPath?: string): string {
+        if (!rootPath) {
+            throw new Error("Not in a VSCode workspace");
+        }
+        let cwd = path.normalize(rootPath);
         return path.join(cwd, ".databricks", "project.json");
     }
 }

packages/databricks-vscode/src/configuration/ProjectConfigFileWatcher.ts

@@ -0,0 +1,36 @@
+import {Disposable, workspace} from "vscode";
+import {ConnectionManager} from "./ConnectionManager";
+import {ProjectConfigFile} from "./ProjectConfigFile";
+
+export class ProjectConfigFileWatcher implements Disposable {
+    private disposables: Array<Disposable> = [];
+    constructor(
+        readonly connectionManager: ConnectionManager,
+        rootPath?: string
+    ) {
+        const fileSystemWatcher = workspace.createFileSystemWatcher(
+            ProjectConfigFile.getProjectConfigFilePath(rootPath)
+        );
+
+        this.disposables.push(
+            fileSystemWatcher,
+            fileSystemWatcher.onDidCreate(async (e) => {
+                if (connectionManager.state !== "CONNECTED") {
+                    connectionManager.login();
+                }
+            }, this),
+            fileSystemWatcher.onDidChange(async (e) => {
+                const configFile = await ProjectConfigFile.load(rootPath);
+                if (configFile.profile !== connectionManager.profile) {
+                    connectionManager.login();
+                }
+            }, this),
+            fileSystemWatcher.onDidDelete((e) => {
+                connectionManager.logout();
+            }, this)
+        );
+    }
+    dispose() {
+        this.disposables.forEach((item) => item.dispose());
+    }
+}

packages/databricks-vscode/src/extension.ts

@@ -1,4 +1,11 @@
-import {commands, debug, ExtensionContext, tasks, window} from "vscode";
+import {
+    commands,
+    debug,
+    ExtensionContext,
+    tasks,
+    window,
+    workspace,
+} from "vscode";
 import {CliWrapper} from "./cli/CliWrapper";
 import {ConnectionCommands} from "./configuration/ConnectionCommands";
 import {ConnectionManager} from "./configuration/ConnectionManager";
@@ -13,6 +20,7 @@ import {DatabricksWorkflowDebugAdapterFactory} from "./run/DabaricksWorkflowDebu
 import {SyncCommands} from "./sync/SyncCommands";
 import {CodeSynchronizer} from "./sync/CodeSynchronizer";
 import {BricksTaskProvider} from "./cli/BricksTasks";
+import {ProjectConfigFileWatcher} from "./configuration/ProjectConfigFileWatcher";
 
 export function activate(context: ExtensionContext) {
     let cli = new CliWrapper(context);
@@ -176,6 +184,10 @@ export function activate(context: ExtensionContext) {
             cliCommands
         )
     );
+
+    context.subscriptions.push(
+        new ProjectConfigFileWatcher(connectionManager, workspace.rootPath)
+    );
 }
 
 // this method is called when your extension is deactivated