Merge pull request #202 from matthewpwilson/subtask-progress

Improve progress bar updating

Author: pcoop

__tests__/api/BundleDeploy/BundleDeployer.test.ts

@@ -12,7 +12,6 @@
 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";
 
 
@@ -69,6 +68,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" ); });
@@ -506,6 +508,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,111 @@
+/*
+* This program and the accompanying materials are made available under the terms of the
+* Eclipse Public License v2.0 which accompanies this distribution, and is available at
+* https://www.eclipse.org/legal/epl-v20.html
+*
+* SPDX-License-Identifier: EPL-2.0
+*
+* Copyright IBM Corp, 2019
+*
+*/
+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);
+    });
+
+    it("should allow really small increments", () => {
+        const subTask = new SubtaskWithStatus(parentTask, 40);
+        subTask.percentComplete = 50;
+        for (let i = 0; i < 40; i++) {
+            subTask.percentComplete += 0.25;
+        }
+        expect(parentTask.percentComplete).toBeCloseTo(24);
+
+    });
+
+    it("should return subtask stage", () => {
+        const subTask = new SubtaskWithStatus(parentTask, 40);
+        subTask.stageName = TaskStage.IN_PROGRESS;
+        expect(subTask.stageName).toEqual(TaskStage.IN_PROGRESS);
+    });
+
+    it("should return subtask status message", () => {
+        const subTask = new SubtaskWithStatus(parentTask, 40);
+        subTask.statusMessage = "Status";
+        expect(subTask.statusMessage).toEqual("Status");
+    });
+});

src/api/BundleDeploy/BundleDeployer.ts

@@ -33,6 +33,7 @@ export class BundleDeployer {
   private hlqsValidated: boolean = false;
   private jobId: string;
   private progressBar: ITaskWithStatus;
+  private useResponseProgressBar = true;
   private jobOutput: string = "";
 
   /**
@@ -43,6 +44,9 @@ export class BundleDeployer {
    */
   constructor(params: IHandlerParameters) {
     this.params = params;
+    this.progressBar = { percentComplete: 0,
+                         stageName: TaskStage.NOT_STARTED,
+                         statusMessage: ""};
   }
 
   /**
@@ -52,7 +56,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();
@@ -69,7 +73,7 @@ export class BundleDeployer {
     const jcl = this.getDeployJCL();
 
     // Submit it
-    return this.submitJCL(jcl, "DEPLOY", session);
+    return this.submitJCL(jcl, "DEPLOY", session, task);
   }
 
   /**
@@ -79,7 +83,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();
@@ -96,7 +100,7 @@ export class BundleDeployer {
     const jcl = this.getUndeployJCL();
 
     // Submit it
-    return this.submitJCL(jcl, "UNDEPLOY", session);
+    return this.submitJCL(jcl, "UNDEPLOY", session, task);
   }
 
   /**
@@ -271,7 +275,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) {
@@ -300,11 +304,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";
     this.jobOutput = "";
@@ -402,13 +412,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

@@ -16,6 +16,7 @@ import { List, ZosmfSession, SshSession, Shell, Upload, IUploadOptions, ZosFiles
 import { getResource, IResourceParms } from "@zowe/cics";
 import { BundleDeployer } from "../BundleDeploy/BundleDeployer";
 import { Bundle } from "../BundleContent/Bundle";
+import { SubtaskWithStatus } from "./SubtaskWithStatus";
 
 
 /**
@@ -327,11 +328,11 @@ 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 bundle '" + this.params.arguments.name + "' 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
@@ -343,12 +344,12 @@ export class BundlePusher {
   private async deployBundle(zosMFSession: AbstractSession, bd: BundleDeployer, cicsSession: AbstractSession, bundle: Bundle) {
     // End the current progress bar so that DEPLOY can create its own
     this.updateStatus("Deploying bundle '" + this.params.arguments.name + "' to CICS");
-    this.endProgressBar();
+    const subtask = new SubtaskWithStatus(this.progressBar, TaskProgress.THIRTY_PERCENT);
 
     let deployError: Error;
     let dfhdployOutput = "";
     try {
-      await bd.deployBundle(zosMFSession);
+      await bd.deployBundle(zosMFSession, subtask);
     }
     catch (error) {
       // temporarily ignore the error as we might want to generate additional resource
@@ -520,6 +521,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);
@@ -548,10 +550,9 @@ export class BundlePusher {
     return new ZosFilesAttributes(Bundle.getTemplateZosAttributesFile());
   }
 
-  private updateStatus(status: string) {
-    const PERCENT5 = 5;
+  private updateStatus(status: string, percentageIncrease = 3) {
     const MAX_PROGRESS_BAR_MESSAGE = 60;
-    this.progressBar.percentComplete += PERCENT5;
+    this.progressBar.percentComplete += percentageIncrease;
 
     if (status.length > MAX_PROGRESS_BAR_MESSAGE)
     {

src/api/BundlePush/SubtaskWithStatus.ts

@@ -0,0 +1,56 @@
+/*
+* This program and the accompanying materials are made available under the terms of the
+* Eclipse Public License v2.0 which accompanies this distribution, and is available at
+* https://www.eclipse.org/legal/epl-v20.html
+*
+* SPDX-License-Identifier: EPL-2.0
+*
+* Copyright IBM Corp, 2019
+*
+*/
+import { ITaskWithStatus, TaskProgress, TaskStage, ImperativeExpect, ImperativeError, Logger} 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 get statusMessage() {
+        return this.parent.statusMessage;
+    }
+
+    public set stageName(stageName: TaskStage) {
+        if (stageName !== TaskStage.COMPLETE && stageName !== TaskStage.NOT_STARTED) {
+            this.parent.stageName = stageName;
+        }
+    }
+
+    public get stageName() {
+        return this.parent.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;
+    }
+}