Initial attempt at progress bar improvements

Author: matthewpwilson

__tests__/api/BundleDeploy/BundleDeployer.test.ts

@@ -13,7 +13,7 @@ import { BundleDeployer } from "../../../src/api/BundleDeploy/BundleDeployer";
 import { IHandlerParameters, TaskStage } from "@zowe/imperative";
 import * as DeployBundleDefinition from "../../../src/cli/deploy/bundle/DeployBundle.definition";
 import * as fse from "fs-extra";
-import { ZosmfSession, SubmitJobs, List } from "@zowe/cli";
+import { ZosmfSession, SubmitJobs, List, explainProvisionedInstanceExtended } from "@zowe/cli";
 
 
 const DEFAULT_PARAMTERS: IHandlerParameters = {
@@ -69,6 +69,9 @@ describe("BundleDeployer01", () => {
     });
     afterEach(() => {
         jest.restoreAllMocks();
+        (DEFAULT_PARAMTERS.response.progress.startBar as jest.Mock).mockReset();
+        (DEFAULT_PARAMTERS.response.progress.endBar as jest.Mock).mockReset();
+
     });
     it("should complain with missing zOSMF profile for deploy", async () => {
         createSpy.mockImplementationOnce(() => { throw new Error( "Injected Create error" ); });
@@ -499,6 +502,24 @@ describe("BundleDeployer01", () => {
         parms.arguments.verbose = false;
         await testUndeployJCL(parms);
     });
+
+    it("should use task passed as parameter on deploy", async () => {
+        submitSpy.mockImplementationOnce(() => [{ddName: "SYSTSPRT", stepName: "DFHDPLOY", data: "DFHRL2012I"}] );
+
+        let parms: IHandlerParameters;
+        parms = DEFAULT_PARAMTERS;
+        setCommonParmsForDeployTests(parms);
+        parms.arguments.csdgroup = "12345678";
+
+        const bd = new BundleDeployer(parms);
+        const task = { percentComplete: 0, stageName: TaskStage.NOT_STARTED, statusMessage: ""};
+        const response = await bd.deployBundle(undefined, task);
+        expect(task.stageName).toEqual(TaskStage.COMPLETE);
+        expect(task.statusMessage).toEqual("Completed DFHDPLOY");
+        expect(parms.response.progress.startBar).toHaveBeenCalledTimes(0);
+        expect(parms.response.progress.endBar).toHaveBeenCalledTimes(0);
+
+    });
 });
 
 async function runDeployTestWithError() {

__tests__/api/BundlePush/SubtaskWithStatus.test.ts

@@ -0,0 +1,79 @@
+import { SubtaskWithStatus } from "../../../src/api/BundlePush/SubtaskWithStatus";
+import { TaskStage, ITaskWithStatus, TaskProgress } from "@zowe/imperative";
+
+
+let parentTask: ITaskWithStatus;
+
+describe("SubtaskWithStatus", () => {
+
+    beforeEach(() => {
+        parentTask =  {
+            percentComplete: 0,
+            statusMessage: "status",
+            stageName: TaskStage.IN_PROGRESS
+        };
+    });
+    it("Should fail with ticks < 0", () => {
+        expect(() => {
+            const task = new SubtaskWithStatus(parentTask, -1);
+        }).toThrow("Ticks must be between 0 and 100");
+    });
+
+    it("Should fail with ticks > 0", () => {
+        expect(() => {
+            const task = new SubtaskWithStatus(parentTask, 101);
+        }).toThrow("Ticks must be between 0 and 100");
+    });
+
+    it("Should set the parent task status", () => {
+        const subTask = new SubtaskWithStatus(parentTask, 20);
+        subTask.statusMessage = "Message from subtask";
+        expect(parentTask.statusMessage).toEqual("Message from subtask");
+    });
+
+    it("Should set the parent task stage", () => {
+        const subTask = new SubtaskWithStatus(parentTask, 20);
+        subTask.stageName = TaskStage.FAILED;
+        expect(parentTask.stageName).toEqual(TaskStage.FAILED);
+    });
+
+    it("Should not set the parent task to completed", () => {
+        const subTask = new SubtaskWithStatus(parentTask, 20);
+        subTask.stageName = TaskStage.COMPLETE;
+        expect(parentTask.stageName).toEqual(TaskStage.IN_PROGRESS);
+    });
+
+    it("Should not set the parent task to NOT_STARTED", () => {
+        const subTask = new SubtaskWithStatus(parentTask, 20);
+        subTask.stageName = TaskStage.NOT_STARTED;
+        expect(parentTask.stageName).toEqual(TaskStage.IN_PROGRESS);
+    });
+
+    it("should set percentComplete on parent task using scaled value", () => {
+        const subTask = new SubtaskWithStatus(parentTask, 20);
+        subTask.percentComplete = TaskProgress.FIFTY_PERCENT;
+        expect(parentTask.percentComplete).toEqual(TaskProgress.TEN_PERCENT);
+    });
+
+    it("should add to percentComplete on parent task using scaled value", () => {
+        const subTask = new SubtaskWithStatus(parentTask, 40);
+        parentTask.percentComplete = 50;
+        subTask.percentComplete = TaskProgress.FIFTY_PERCENT;
+        expect(parentTask.percentComplete).toEqual(TaskProgress.SEVENTY_PERCENT);
+    });
+
+    it("should add to percentComplete on parent task using scaled value multiple times", () => {
+        const subTask = new SubtaskWithStatus(parentTask, 40);
+        parentTask.percentComplete = TaskProgress.FIFTY_PERCENT;
+        subTask.percentComplete = 25;
+        subTask.percentComplete = 50;
+        subTask.percentComplete = 75;
+        expect(parentTask.percentComplete).toEqual(TaskProgress.EIGHTY_PERCENT);
+    });
+
+    it("should return subtask percentage complete", () => {
+        const subTask = new SubtaskWithStatus(parentTask, 40);
+        subTask.percentComplete = 50;
+        expect(subTask.percentComplete).toEqual(50);
+    });
+});

src/api/BundleDeploy/BundleDeployer.ts

@@ -32,6 +32,7 @@ export class BundleDeployer {
   private hlqsValidated: boolean = false;
   private jobId: string;
   private progressBar: ITaskWithStatus;
+  private useResponseProgressBar = true;
 
   /**
    * Constructor for a BundleDeployer.
@@ -41,6 +42,9 @@ export class BundleDeployer {
    */
   constructor(params: IHandlerParameters) {
     this.params = params;
+    this.progressBar = { percentComplete: 0,
+                         stageName: TaskStage.NOT_STARTED,
+                         statusMessage: ""};
   }
 
   /**
@@ -50,7 +54,7 @@ export class BundleDeployer {
    * @throws ImperativeError
    * @memberof BundleDeployer
    */
-  public async deployBundle(session?: AbstractSession): Promise<string> {
+  public async deployBundle(session?: AbstractSession, task?: ITaskWithStatus): Promise<string> {
 
     // Validate that the parms are valid for Deploy
     this.validateDeployParms();
@@ -67,7 +71,7 @@ export class BundleDeployer {
     const jcl = this.getDeployJCL();
 
     // Submit it
-    return this.submitJCL(jcl, "DEPLOY", session);
+    return this.submitJCL(jcl, "DEPLOY", session, task);
   }
 
   /**
@@ -77,7 +81,7 @@ export class BundleDeployer {
    * @throws ImperativeError
    * @memberof BundleDeployer
    */
-  public async undeployBundle(session?: AbstractSession): Promise<string> {
+  public async undeployBundle(session?: AbstractSession, task?: ITaskWithStatus): Promise<string> {
 
     // Validate that the parms are valid for Undeploy
     this.validateUndeployParms();
@@ -94,7 +98,7 @@ export class BundleDeployer {
     const jcl = this.getUndeployJCL();
 
     // Submit it
-    return this.submitJCL(jcl, "UNDEPLOY", session);
+    return this.submitJCL(jcl, "UNDEPLOY", session, task);
   }
 
   /**
@@ -257,7 +261,7 @@ export class BundleDeployer {
 
     // Have a look at the status message for the progress bar, has it been updated with
     // the jobid yet? If so, parse it out and refresh the message.
-    if (this.jobId === "UNKNOWN") {
+    if (this.jobId === "UNKNOWN" && this.progressBar.statusMessage) {
       const statusWords = this.progressBar.statusMessage.split(" ");
       if (statusWords.length >= 2) {
         if (statusWords[2] !== undefined && statusWords[2].indexOf("JOB") === 0) {
@@ -286,11 +290,17 @@ export class BundleDeployer {
     }
   }
 
-  private async submitJCL(jcl: string, action: string, session: any): Promise<string> {
+  private async submitJCL(jcl: string, action: string, session: any, task?: ITaskWithStatus): Promise<string> {
     let spoolOutput: any;
-    this.progressBar = { percentComplete: TaskProgress.TEN_PERCENT,
-                         statusMessage: "Submitting DFHDPLOY JCL for the " + action + " action",
-                         stageName: TaskStage.IN_PROGRESS };
+    if (task) {
+        this.progressBar = task;
+        this.useResponseProgressBar = false;
+    }
+
+    this.progressBar.percentComplete = TaskProgress.TEN_PERCENT;
+    this.progressBar.statusMessage = "Submitting DFHDPLOY JCL for the " + action + " action";
+    this.progressBar.stageName = TaskStage.IN_PROGRESS;
+
     this.startProgressBar();
     this.jobId = "UNKNOWN";
 
@@ -386,13 +396,13 @@ export class BundleDeployer {
   }
 
   private startProgressBar() {
-    if (this.params.arguments.verbose !== true) {
+    if (this.params.arguments.verbose !== true && this.useResponseProgressBar === true) {
       this.params.response.progress.startBar({task: this.progressBar});
     }
   }
 
   private endProgressBar() {
-    if (this.params.arguments.verbose !== true) {
+    if (this.params.arguments.verbose !== true && this.useResponseProgressBar === true) {
       this.params.response.progress.endBar();
     }
   }

src/api/BundlePush/BundlePusher.ts

@@ -11,10 +11,11 @@
 
 "use strict";
 
-import { IHandlerParameters, AbstractSession, ITaskWithStatus, TaskStage, Logger } from "@zowe/imperative";
+import { IHandlerParameters, AbstractSession, ITaskWithStatus, TaskStage, Logger, TaskProgress } from "@zowe/imperative";
 import { List, ZosmfSession, SshSession, Shell, Upload, IUploadOptions, ZosFilesAttributes, Create } from "@zowe/cli";
 import { BundleDeployer } from "../BundleDeploy/BundleDeployer";
 import { Bundle } from "../BundleContent/Bundle";
+import { SubtaskWithStatus } from "./SubtaskWithStatus";
 
 
 /**
@@ -221,32 +222,23 @@ export class BundlePusher {
   }
 
   private async undeployExistingBundle(zosMFSession: AbstractSession, bd: BundleDeployer) {
-    // End the current progress bar so that UNDEPLOY can create its own
     this.updateStatus("Undeploying any existing bundle from CICS");
-    this.endProgressBar();
-
 
     const targetstateLocal = this.params.arguments.targetstate;
     this.params.arguments.targetstate = "DISCARDED";
-    await bd.undeployBundle(zosMFSession);
+    const subtask = new SubtaskWithStatus(this.progressBar, TaskProgress.THIRTY_PERCENT);
+    await bd.undeployBundle(zosMFSession, subtask);
     this.params.arguments.targetstate = targetstateLocal;
 
     // Resume the current progress bar
-    this.endProgressBar();
     this.updateStatus("Undeployed existing bundle from CICS");
-    this.startProgressBar();
   }
 
   private async deployBundle(zosMFSession: AbstractSession, bd: BundleDeployer) {
-    // End the current progress bar so that DEPLOY can create its own
     this.updateStatus("Deploying the bundle to CICS");
-    this.endProgressBar();
-
-    await bd.deployBundle(zosMFSession);
-    // Resume the current progress bar
-    this.endProgressBar();
+    const subtask = new SubtaskWithStatus(this.progressBar, TaskProgress.THIRTY_PERCENT);
+    await bd.deployBundle(zosMFSession, subtask);
     this.updateStatus("Deployed existing bundle to CICS");
-    this.startProgressBar();
   }
 
   private sshOutput(data: string) {
@@ -312,6 +304,7 @@ export class BundlePusher {
     // architected .profile within the USSCONFIG structure.
     const setNodehomeCmd = "export PATH=\"$PATH:/usr/lpp/IBM/cnj/IBM/node-latest-os390-s390x/bin\"";
     await this.runSshCommandInRemoteDirectory(sshSession, this.params.arguments.bundledir, setNodehomeCmd + " && npm install");
+    this.updateStatus("npm install complete", TaskProgress.TWENTY_PERCENT);
   }
 
   private async runSshCommandInRemoteDirectory(sshSession: SshSession, directory: string, sshCommand: string) {
@@ -357,6 +350,7 @@ export class BundlePusher {
 
     const uploadOptions: IUploadOptions = { recursive: true };
     uploadOptions.attributes = this.findZosAttributes();
+    uploadOptions.task = new SubtaskWithStatus(this.progressBar, TaskProgress.TEN_PERCENT);
 
     try {
       await Upload.dirToUSSDirRecursive(zosMFSession, this.localDirectory, this.params.arguments.bundledir, uploadOptions);
@@ -392,9 +386,8 @@ export class BundlePusher {
     return new ZosFilesAttributes(Bundle.getTemplateZosAttributesFile());
   }
 
-  private updateStatus(status: string) {
-    const PERCENT3 = 3;
-    this.progressBar.percentComplete += PERCENT3;
+  private updateStatus(status: string, percentageIncrease = 3) {
+    this.progressBar.percentComplete += percentageIncrease;
     this.progressBar.statusMessage = status;
 
     if (this.params.arguments.verbose) {

src/api/BundlePush/SubtaskWithStatus.ts

@@ -0,0 +1,38 @@
+import { ITaskWithStatus, TaskProgress, TaskStage, ImperativeExpect, ImperativeError} from "@zowe/imperative";
+
+
+export class SubtaskWithStatus {
+
+    private parent: ITaskWithStatus;
+    private ticks: number;
+    private percentCompleteInternal: number;
+
+    constructor(parent: ITaskWithStatus, ticks: number) {
+        this.parent = parent;
+        this.ticks = ticks;
+        this.percentCompleteInternal = 0;
+        if (this.ticks < 0 || this.ticks > TaskProgress.ONE_HUNDRED_PERCENT) {
+            throw new ImperativeError({msg: "Ticks must be between 0 and 100"});
+        }
+    }
+
+    public set statusMessage(statusMessage: string) {
+        this.parent.statusMessage = statusMessage;
+    }
+
+    public set stageName(stageName: TaskStage) {
+        if (stageName !== TaskStage.COMPLETE && stageName !== TaskStage.NOT_STARTED) {
+            this.parent.stageName = stageName;
+        }
+    }
+
+    public set percentComplete(percentComplete: number) {
+        const delta = percentComplete - this.percentCompleteInternal;
+        this.percentCompleteInternal = percentComplete;
+        this.parent.percentComplete = this.parent.percentComplete + delta * (this.ticks / TaskProgress.ONE_HUNDRED_PERCENT);
+    }
+
+    public get percentComplete() {
+        return this.percentCompleteInternal;
+    }
+}