[WIP] refactor ServerlessFunction -> ServerlessFunctionModel

Signed-off-by: David Thompson <davthomp@redhat.com>

Author: datho7561

src/extension.ts

@@ -21,7 +21,6 @@ import { extendClusterExplorer } from './k8s/clusterExplorer';
 import { Cluster } from './openshift/cluster';
 import { Component } from './openshift/component';
 import { ComponentTypesView } from './registriesView';
-import { ServerlessFunctionImpl } from './serverlessFunction/functionImpl';
 import { ServerlessFunctionView } from './serverlessFunction/view';
 import { startTelemetry } from './telemetry';
 import { ToolsConfig } from './tools';
@@ -95,7 +94,6 @@ export async function activate(extensionContext: ExtensionContext): Promise<unkn
         ...Component.init(),
         ComponentTypesView.instance.createTreeView('openshiftComponentTypesView'),
         ServerlessFunctionView.getInstance(),
-        ServerlessFunctionImpl.Instance,
         ComponentsTreeDataProvider.instance.createTreeView('openshiftComponentsView'),
         setupWorkspaceDevfileContext(),
     ];

src/serverlessFunction/functionImpl.ts src/serverlessFunction/functionModel.tssrc/serverlessFunction/functionImpl.ts renamed to src/serverlessFunction/functionModel.ts

@@ -3,125 +3,39 @@
  *  Licensed under the MIT License. See LICENSE file in the project root for license information.
  *-----------------------------------------------------------------------------------------------*/
 
-import * as cp from 'child_process';
 import * as fs from 'fs-extra';
-import { dump } from 'js-yaml';
 import * as path from 'path';
-import { Disposable, Uri, window, workspace } from 'vscode';
+import { Disposable, Uri, workspace } from 'vscode';
 import { CommandText } from '../base/command';
 import { CliChannel } from '../cli';
 import { DeploymentConfig } from '../k8s/deploymentConfig';
-import { OdoImpl } from '../odo';
-import { CliExitData } from '../util/childProcessUtil';
-import { VsCommandError } from '../vscommand';
-import { ServerlessCommand, Utils } from './commands';
+import { Utils } from './commands';
 import { Functions } from './functions';
 import { DeployedFunction, FunctionContent, FunctionObject, FunctionStatus } from './types';
-import { ServerlessFunctionView } from './view';
 
-export interface ServerlessFunction extends Disposable {
-    getLocalFunctions(): Promise<FunctionObject[]>;
-    createFunction(language: string, template: string, location: string, image: string): Promise<CliExitData>;
+export interface View {
+    refresh(): void;
 }
 
-export class ServerlessFunctionImpl implements ServerlessFunction {
-    private static instance: ServerlessFunction = new ServerlessFunctionImpl();
+export class ServerlessFunctionModel implements Disposable {
 
     private watchers: fs.FSWatcher[] = [];
     private workspaceWatcher: Disposable;
+    private view: View;
 
-    public static get Instance(): ServerlessFunction {
-        return ServerlessFunctionImpl.instance;
-    }
-
-    private constructor() {
+    public constructor(view: View) {
+        this.view = view;
         this.addWatchers();
         this.workspaceWatcher = workspace.onDidChangeWorkspaceFolders((_e) => {
             for (const watcher of this.watchers) {
                 watcher.close();
             }
-            ServerlessFunctionView.getInstance().refresh();
+            this.view.refresh();
             this.addWatchers();
         });
     }
 
-    private addWatchers() {
-        if (workspace.workspaceFolders) {
-            for (const workspaceFolder of workspace.workspaceFolders) {
-                this.watchers.push(
-                    fs.watch(workspaceFolder.uri.fsPath, (_event, filename) => {
-                        if (filename === 'func.yaml') {
-                            ServerlessFunctionView.getInstance().refresh();
-                        }
-                    }),
-                );
-            }
-        }
-    }
-
-    private async getListItems(command: CommandText, fail = false) {
-        const listCliExitData = await CliChannel.getInstance().executeTool(
-            command,
-            undefined,
-            fail,
-        );
-        try {
-            return JSON.parse(listCliExitData.stdout) as FunctionObject[];
-        } catch (err) {
-            return [];
-        }
-    }
-
-    private async getDeployedFunctions(): Promise<FunctionObject[]> {
-        return this.getListItems(DeploymentConfig.command.getDeploymentFunctions());
-    }
-
-    async createFunction(
-        language: string,
-        template: string,
-        location: string,
-        image: string,
-    ): Promise<CliExitData> {
-        let functionResponse: CliExitData;
-        try {
-            const response = await OdoImpl.Instance.execute(
-                ServerlessCommand.createFunction(language, template, location),
-            );
-            if (response && !response.error) {
-                const yamlContent = await Utils.getFuncYamlContent(location);
-                if (yamlContent) {
-                    yamlContent.image = image;
-                    await fs.rm(path.join(location, 'func.yaml'));
-                    await fs.writeFile(
-                        path.join(location, 'func.yaml'),
-                        dump(yamlContent),
-                        'utf-8',
-                    );
-                    functionResponse = {
-                        error: undefined,
-                        stderr: '',
-                        stdout: 'Success',
-                    };
-                }
-            } else {
-                await fs.rmdir(location);
-                functionResponse = response;
-            }
-        } catch (err) {
-            if (err instanceof VsCommandError) {
-                void window.showErrorMessage(err.message);
-            }
-            await fs.rmdir(location);
-            functionResponse = {
-                error: err as cp.ExecException,
-                stderr: '',
-                stdout: '',
-            };
-        }
-        return functionResponse;
-    }
-
-    async getLocalFunctions(): Promise<FunctionObject[]> {
+    public async getLocalFunctions(): Promise<FunctionObject[]> {
         const functionList: FunctionObject[] = [];
         const folders: Uri[] = [];
         if (workspace.workspaceFolders) {
@@ -172,7 +86,14 @@ export class ServerlessFunctionImpl implements ServerlessFunction {
         return functionList;
     }
 
-    getDeployFunction(
+    public dispose() {
+        for (const watcher of this.watchers) {
+            watcher.close();
+        }
+        this.workspaceWatcher.dispose();
+    }
+
+    private getDeployFunction(
         funcData: FunctionContent,
         deployedFunctions: FunctionObject[],
     ): DeployedFunction {
@@ -192,19 +113,39 @@ export class ServerlessFunctionImpl implements ServerlessFunction {
         return { status: FunctionStatus.LOCALONLY, url: '' } as DeployedFunction;
     }
 
-    dispose() {
-        for (const watcher of this.watchers) {
-            watcher.close();
+    private async checkImage(folderUri: Uri): Promise<boolean> {
+        const yamlContent = await Utils.getFuncYamlContent(folderUri.fsPath);
+        return Functions.imageRegex.test(yamlContent?.image);
+    }
+
+    private addWatchers() {
+        if (workspace.workspaceFolders) {
+            for (const workspaceFolder of workspace.workspaceFolders) {
+                this.watchers.push(
+                    fs.watch(workspaceFolder.uri.fsPath, (_event, filename) => {
+                        if (filename === 'func.yaml') {
+                            this.view.refresh();
+                        }
+                    }),
+                );
+            }
         }
-        this.workspaceWatcher.dispose();
     }
 
-    async checkImage(folderUri: Uri): Promise<boolean> {
-        const yamlContent = await Utils.getFuncYamlContent(folderUri.fsPath);
-        return Functions.imageRegex.test(yamlContent?.image);
+    private async getListItems(command: CommandText, fail = false) {
+        const listCliExitData = await CliChannel.getInstance().executeTool(
+            command,
+            undefined,
+            fail,
+        );
+        try {
+            return JSON.parse(listCliExitData.stdout) as FunctionObject[];
+        } catch (err) {
+            return [];
+        }
     }
-}
 
-export function serverlessInstance(): ServerlessFunction {
-    return ServerlessFunctionImpl.Instance;
+    private async getDeployedFunctions(): Promise<FunctionObject[]> {
+        return this.getListItems(DeploymentConfig.command.getDeploymentFunctions());
+    }
 }

src/serverlessFunction/view.ts

@@ -27,7 +27,7 @@ import { FileContentChangeNotifier, WatchUtil } from '../util/watch';
 import { vsCommand } from '../vscommand';
 import ServerlessFunctionViewLoader from '../webview/serverless-function/serverlessFunctionLoader';
 import ManageRepositoryViewLoader from '../webview/serverless-manage-repository/manageRepositoryLoader';
-import { ServerlessFunction, serverlessInstance } from './functionImpl';
+import { ServerlessFunctionModel } from './functionModel';
 import { Functions } from './functions';
 import { FunctionContextType, FunctionObject, FunctionStatus } from './types';
 
@@ -51,9 +51,10 @@ export class ServerlessFunctionView implements TreeDataProvider<ExplorerItem>, D
     readonly onDidChangeTreeData: Event<ExplorerItem | undefined> = this
         .eventEmitter.event;
 
-    private serverlessFunction: ServerlessFunction = serverlessInstance();
+    private serverlessFunction: ServerlessFunctionModel;
 
     private constructor() {
+        this.serverlessFunction = new ServerlessFunctionModel(this);
         try {
             this.kubeConfig = new KubeConfigUtils();
             this.kubeContext = this.kubeConfig.getContextObject(this.kubeConfig.currentContext);
@@ -197,6 +198,7 @@ export class ServerlessFunctionView implements TreeDataProvider<ExplorerItem>, D
     dispose(): void {
         this.fsw?.watcher?.close();
         this.treeView.dispose();
+        this.serverlessFunction.dispose();
     }
 
     @vsCommand('openshift.Serverless.createFunction')

src/webview/serverless-function/serverlessFunctionLoader.ts

@@ -2,24 +2,29 @@
  *  Copyright (c) Red Hat, Inc. All rights reserved.
  *  Licensed under the MIT License. See LICENSE file in the project root for license information.
  *-----------------------------------------------------------------------------------------------*/
+import * as cp from 'child_process';
 import * as crypto from 'crypto';
+import * as fs from 'fs/promises';
+import * as JSYAML from 'js-yaml';
 import * as path from 'path';
 import * as vscode from 'vscode';
-import { serverlessInstance } from '../../serverlessFunction/functionImpl';
+import { OdoImpl } from '../../odo';
+import { ServerlessCommand, Utils } from '../../serverlessFunction/commands';
 import { Functions } from '../../serverlessFunction/functions';
 import { InvokeFunction } from '../../serverlessFunction/types';
 import { CliExitData } from '../../util/childProcessUtil';
 import { ExtensionID } from '../../util/constants';
 import { Progress } from '../../util/progress';
 import { selectWorkspaceFolder, selectWorkspaceFolders } from '../../util/workspace';
+import { VsCommandError } from '../../vscommand';
 import { loadWebviewHtml, validateName } from '../common-ext/utils';
 
 export interface ServiceBindingFormResponse {
     selectedService: string;
     bindingName: string;
 }
 
-async function gitImportMessageListener(panel: vscode.WebviewPanel, event: any): Promise<any> {
+async function messageListener(panel: vscode.WebviewPanel, event: any): Promise<any> {
     let response: CliExitData;
     const eventName = event.action;
     const functionName = event.name;
@@ -63,7 +68,7 @@ async function gitImportMessageListener(panel: vscode.WebviewPanel, event: any):
             await Progress.execFunctionWithProgress(
                 `Creating function '${functionName}'`,
                 async () => {
-                    response = await serverlessInstance().createFunction(event.language, event.template, selctedFolder.fsPath, event.selectedImage);
+                    response = await ServerlessFunctionViewLoader.createFunction(event.language, event.template, selctedFolder.fsPath, event.selectedImage);
                 });
             if (response && response.error) {
                 void vscode.window.showErrorMessage(`Error while creating the function ${functionName}`);
@@ -174,7 +179,7 @@ export default class ServerlessFunctionViewLoader {
             'serverlessFunctionViewer',
             panel,
         );
-        panel.webview.onDidReceiveMessage((e) => gitImportMessageListener(panel, e));
+        panel.webview.onDidReceiveMessage((e) => messageListener(panel, e));
 
         panel.onDidDispose(() => {
             if (ServerlessFunctionViewLoader.invokePanelMap.has(title)) {
@@ -185,5 +190,49 @@ export default class ServerlessFunctionViewLoader {
 
         return Promise.resolve(panel);
     }
-}
 
+    static async createFunction(
+        language: string,
+        template: string,
+        location: string,
+        image: string,
+    ): Promise<CliExitData> {
+        let functionResponse: CliExitData;
+        try {
+            const response = await OdoImpl.Instance.execute(
+                ServerlessCommand.createFunction(language, template, location),
+            );
+            if (response && !response.error) {
+                const yamlContent = await Utils.getFuncYamlContent(location);
+                if (yamlContent) {
+                    yamlContent.image = image;
+                    await fs.rm(path.join(location, 'func.yaml'));
+                    await fs.writeFile(
+                        path.join(location, 'func.yaml'),
+                        JSYAML.dump(yamlContent),
+                        'utf-8',
+                    );
+                    functionResponse = {
+                        error: undefined,
+                        stderr: '',
+                        stdout: 'Success',
+                    };
+                }
+            } else {
+                await fs.rmdir(location);
+                functionResponse = response;
+            }
+        } catch (err) {
+            if (err instanceof VsCommandError) {
+                void vscode.window.showErrorMessage(err.message);
+            }
+            await fs.rmdir(location);
+            functionResponse = {
+                error: err as cp.ExecException,
+                stderr: '',
+                stdout: '',
+            };
+        }
+        return functionResponse;
+    }
+}