[feat #543] show diff app has changed on sever

- added Application which holds the document to know when app has been changed - added logic if we open a script file to register for app changed event
q-masters · Nov 1, 2020 · Oct 21, 2020 · Oct 21, 2020 · Oct 21, 2020 · Oct 21, 2020
commit 8e9f29685b96da9e17ff02db6e8ff4a4cfb63fb9
diff --git a/src/projects/extension/connection/utils/application.ts b/src/projects/extension/connection/utils/application.ts
@@ -0,0 +1,106 @@
+import { from, Observable, Subject } from "rxjs";
+import { bufferCount, debounce, debounceTime, switchMap, take, takeWhile, tap } from "rxjs/operators";
+
+export class Application {
+
+    private close$: Subject<void> = new Subject();
+
+    /**
+     * broadcast all app changes
+     */
+    private appChange$: Subject<any> = new Subject();
+
+    private docChangeListener: () => void;
+
+    /**
+     * current count of registered observers
+     */
+    private observerCount = 0;
+
+    private doc: Promise<EngineAPI.IApp>;
+
+    public constructor(
+        private globalContext: EngineAPI.IGlobal,
+        private name: string
+    ) {}
+
+    /**
+     * return global context for app
+     */
+    public get global(): EngineAPI.IGlobal {
+        return this.globalContext;
+    }
+
+    /**
+     * returns the active doc, cache the promise since this one
+     * has exactly one of those states fulfilled, rejected which never
+     * changes
+     */
+    public get document(): Promise<EngineAPI.IApp> {
+        if (!this.doc) {
+            this.doc = this.global.openDoc(this.name);
+        }
+        return this.doc;
+    }
+
+    /**
+     * close current app
+     */
+    public async close(): Promise<void> {
+        this.close$.next();
+
+        (await this.document as any).removeListener('changed', this.onDocumentChange.bind(this));
+        await this.global.session.close();
+
+        this.appChange$.complete();
+        this.close$.complete();
+    }
+
+    public onClose(): Observable<void> {
+        return this.close$.asObservable();
+    }
+
+    /**
+     * create a warm observeable which registerns once on app changed event
+     * if the the first one subscribe, for unsusubscript if no listeners left
+     * unregister again from app changed event
+     */
+    public onChanged(): Observable<any> {
+        /** subscribe */
+        return new Observable((observer) => {
+
+            if (this.observerCount === 0) {
+                this.observerCount += 1;
+                this.registerOnDocumentChange();
+            }
+
+            /** subscribe to app changes stream */
+            this.appChange$
+                /** seems to emit twice ... but why ? */
+                .subscribe(observer);
+
+            /** unsubscribe */
+            return () => {
+                this.observerCount -= 1;
+
+                if (this.observerCount === 0) {
+                    this.unregisterOnDocumentChange();
+                }
+            };
+        });
+    }
+
+    private onDocumentChange() {
+        this.appChange$.next();
+    }
+
+    private async registerOnDocumentChange() {
+        const doc = await this.document;
+        doc.on("changed", this.onDocumentChange.bind(this));
+    }
+
+    private async unregisterOnDocumentChange() {
+        const doc = await this.document;
+        (doc as any).removeListener("changed", this.onDocumentChange.bind(this));
+    }
+}
diff --git a/src/projects/extension/connection/utils/connection.helper.ts b/src/projects/extension/connection/utils/connection.helper.ts
@@ -68,6 +68,8 @@ export abstract class ConnectionHelper {
             rejectUnauthorized: !connection.isUntrusted
         });
 
+        logger.debug(uri);
+
         ws.on("message", (message) => logger.verbose(message.toString()));
         ws.on("error", (e) => logger.error(`${connection.setting.label} ${e.message}`));
         return ws;
@@ -102,6 +104,7 @@ export abstract class ConnectionHelper {
             port    : port && !isNaN(port) ? port : connection.secure ? 443 : 80,
             subpath : connection.path ?? ""
         };
+
         return buildUrl(options);
     }
 

diff --git a/src/projects/extension/connection/utils/connection.ts b/src/projects/extension/connection/utils/connection.ts
@@ -17,6 +17,7 @@ import { ConnectionHelper } from "./connection.helper";
 import { EnigmaSession } from "./enigma.provider";
 import { VsQlikLoggerConnection } from "../api";
 import { fetchServerInformation } from "../commands";
+import { Application } from "./application";
 
 /**
  * represents the connection to a server, which is a workspace folder in vscode
@@ -36,6 +37,9 @@ export class Connection {
      */
     private serverStorage: Storage;
 
+    /**
+     *
+     */
     private stateChange$: BehaviorSubject<ConnectionState> = new BehaviorSubject(ConnectionState.CLOSED);
 
     /**
@@ -44,9 +48,18 @@ export class Connection {
     private destroy$: Subject<boolean> = new Subject();
 
     /**
+     * file mapping, so we could easier find a filesystem entry
      */
     private serverFilesystem: FileSystemStorage = new FileSystemStorage();
 
+    /**
+     * open applications
+     */
+    private applications: Map<string, Application> = new Map();
+
+    /**
+     * vsqlik logger for connections
+     */
     private logger: VsQlikLogger;
 
     public constructor(
@@ -114,20 +127,36 @@ export class Connection {
         this.stateChange$.next(ConnectionState.CLOSED);
     }
 
-    public closeSession(appId?: string): Promise<void> {
-        return this.engimaProvider.close(appId);
-    }
-
-    public openSession(appId?: string): Promise<EngineAPI.IGlobal | undefined> {
-        return this.engimaProvider.open(appId);
+    public openSession(): Promise<EngineAPI.IGlobal | undefined> {
+        return this.engimaProvider.open();
     }
 
+    /**
+     * create complete new independed session
+     */
     public createSession(keepAlive = false): Promise<EngineAPI.IGlobal | undefined> {
         return this.engimaProvider.createSession(keepAlive);
     }
 
-    public async openDoc(id: string): Promise<EngineAPI.IApp | undefined> {
-        return this.engimaProvider.openDoc(id);
+    /**
+     * create application wrapper for existing qlik app
+     */
+    public async getApplication(id: string): Promise<Application | undefined> {
+        if (!this.applications.has(id)) {
+            const global = await this.engimaProvider.open(id);
+
+            if (global) {
+                const app = new Application(global, id);
+
+                app.onClose()
+                    .pipe(take(1))
+                    .subscribe(() => this.applications.delete(id));
+
+                /** cache app */
+                this.applications.set(id, app);
+            }
+        }
+        return this.applications.get(id);
     }
 
     /**
@@ -205,10 +234,8 @@ export class Connection {
     protected checkAuthState(): Promise<AuthorizationState> {
         return new Promise((resolve, reject) => {
             const session = ConnectionHelper.createEnigmaSession(this.connectionModel);
-            session.on("traffic:received", (response) => {
-                (session as any).removeAllListeners();
-                session.close();
-
+            session.on("traffic:received", async (response) => {
+                await session.close();
                 switch (response.method) {
                     case 'OnAuthenticationInformation':
                         this.connectionModel.isAuthorizationRequired = true;
@@ -220,10 +247,10 @@ export class Connection {
                         break;
 
                     default:
-                        console.log(response);
                         reject(response);
                 }
             });
+            session.on('closed', () => (session as any).removeAllListeners());
             session.open();
         });
     }

diff --git a/src/projects/extension/connection/utils/enigma.provider.ts b/src/projects/extension/connection/utils/enigma.provider.ts
@@ -108,6 +108,7 @@ export class EnigmaSession {
         if (global) {
             if (!this.docCache.has(global)) {
                 const app = await global.openDoc(name);
+                // global.getActiveDoc();
                 this.docCache.set(global, app);
                 logger.debug(`open new app for ${name} and cached it to docCache`);
             }

diff --git a/src/projects/extension/file-system/data/index.ts b/src/projects/extension/file-system/data/index.ts
@@ -3,10 +3,11 @@ export * from "./routes";
 
 export enum EntryType {
     APPLICATION,
-    MEASURE,
     DIMENSION,
-    STREAM,
+    MEASURE,
+    SCRIPT,
     SHEET,
+    STREAM,
     VARIABLE,
     VISUALIZATION,
     UNKNOWN

diff --git a/src/projects/extension/file-system/entry/application/app-list.my-work.directory.ts b/src/projects/extension/file-system/entry/application/app-list.my-work.directory.ts
@@ -64,8 +64,6 @@ export class AppListMyWorkDirectory extends AppListDirectory {
             }
 
             await this.applicationProvider.deleteApp(connection, fsEntry.id);
-            await connection.closeSession(fsEntry.id);
-
             connection.fileSystem.deleteDirectory(uri);
         }
     }

diff --git a/src/projects/extension/file-system/entry/script/script.directory.ts b/src/projects/extension/file-system/entry/script/script.directory.ts
@@ -3,6 +3,9 @@ import { injectable, inject } from "tsyringe";
 import { QixFsDirectoryAdapter } from "../qix/qixfs-entry";
 import { FileSystemHelper } from "../../utils/file-system.helper";
 import { DataNode } from "@core/qix/utils/qix-list.provider";
+import { ConnectionProvider } from "@core/public.api";
+import path from "path";
+import { EntryType } from "@vsqlik/fs/data";
 
 @injectable()
 export class ScriptDirectory extends QixFsDirectoryAdapter{
@@ -22,8 +25,20 @@ export class ScriptDirectory extends QixFsDirectoryAdapter{
         };
     }
 
-    public async readDirectory(): Promise<[string, vscode.FileType][]> {
-        return [["main.qvs", vscode.FileType.File]];
+    public async readDirectory(uri: vscode.Uri): Promise<[string, vscode.FileType][]> {
+        const connection = await this.getConnection(uri);
+        if (connection) {
+            const fileUri  = uri.with({path: path.posix.resolve(uri.path, `main.qvs`)});
+            connection.fileSystem.write(fileUri.toString(true), {
+                id: 'main.qvs',
+                name: 'main',
+                raw: {},
+                type: EntryType.SCRIPT,
+                readonly: false
+            });
+            return [["main.qvs", vscode.FileType.File]];
+        }
+        return [];
     }
 
     public async delete(uri: vscode.Uri, params: DataNode): Promise<void> {

diff --git a/src/projects/extension/script/commands/check-syntax.ts b/src/projects/extension/script/commands/check-syntax.ts
@@ -21,18 +21,21 @@ export async function CheckScriptSyntax(uri: vscode.Uri): Promise<void> {
     }
 
     /** open the app */
-    const app = await connection.openDoc(appEntry.id);
+    const app = await connection.getApplication(appEntry.id);
 
     if (!app) {
         vscode.window.showInformationMessage(`check syntax for file: ${uri.toString(true)} failed. Could not open app.`);
         return;
     }
 
     /** final syntax checks */
-    const errors = await app.checkScriptSyntax();
+    const document = await app.document;
+    const errors   = await document.checkScriptSyntax();
+
     const diagnostics: vscode.Diagnostic[] = [];
+
     if (errors.length) {
-        const script = await app.getScript();
+        const script = await document.getScript();
 
         errors.forEach((error) => {
             const line = script.substring(0, error.qTextPos).split(EOL).length - 1;

diff --git a/src/projects/extension/script/script.module.ts b/src/projects/extension/script/script.module.ts
@@ -2,12 +2,16 @@ import { ExtensionContext } from "@data/tokens";
 import * as vscode from "vscode";
 import { inject, singleton } from "tsyringe";
 import { CheckScriptSyntax, ScriptLoadDataCommand, ScriptResolveActiveCommand } from "./commands";
+import { ConnectionProvider } from "../connection/utils/connection.provider";
+import { EntryType } from "@vsqlik/fs/data";
+import { takeUntil } from "rxjs/operators";
 
 @singleton()
 export class ScriptModule {
 
     constructor(
-        @inject(ExtensionContext) private extensionContext: vscode.ExtensionContext
+        @inject(ExtensionContext) private extensionContext: vscode.ExtensionContext,
+        @inject(ConnectionProvider) private connectionProvider: ConnectionProvider
     ) {}
 
     public bootstrap(): void {
@@ -28,10 +32,38 @@ export class ScriptModule {
      * register connection storage where all sessions are saved to
      */
     private registerEvents(): void {
-        vscode.workspace.onDidOpenTextDocument((doc: vscode.TextDocument) => {
-            if(doc.fileName.match(/\.qvs$/)) {
-                vscode.commands.executeCommand(`VsQlik.Script.CheckSyntax`, doc.uri);
-            }
+
+        vscode.workspace.onDidOpenTextDocument((document) => this.onOpenDocument(document));
+        vscode.workspace.onDidCloseTextDocument((document) => {
+            console.log(`close document`);
+            console.log(document);
         });
     }
+
+    /**
+     * a new textdocument has been opened
+     * check we handle a script file and if we do connect to appChange stream
+     */
+    private async onOpenDocument(doc: vscode.TextDocument) {
+
+        if (doc.uri.scheme !== "qix") {
+            return;
+        }
+
+        /** resolve connection and entry type */
+        const connection = await this.connectionProvider.resolve(doc.uri);
+        const fileEntry  = connection?.fileSystem.read(doc.uri.toString(true));
+        const appEntry   = connection?.fileSystem.parent(doc.uri, EntryType.APPLICATION);
+
+        if (!appEntry || fileEntry?.type !== EntryType.SCRIPT) {
+            return;
+        }
+
+        /** since we handle a script listen to onchange for app here until app get closed */
+        const app = await connection?.getApplication(appEntry.id);
+        app?.onChanged()
+            .subscribe(() => console.log('app changed'));
+
+        vscode.commands.executeCommand(`VsQlik.Script.CheckSyntax`, doc.uri);
+    }
 }
-Original file line number
+Diff line change
@@ Expand Up @@
                 }
                 await this.applicationProvider.deleteApp(connection, fsEntry.id);
-                await connection.closeSession(fsEntry.id);
                 connection.fileSystem.deleteDirectory(uri);
             }
         }
@@ Expand Down @@