@hpcc-js/comms 2.82.3 → 2.83.0

package/src/ecl/dfuWorkunit.ts

@@ -2,7 +2,7 @@ import { Cache, IEvent, scopedLogger, StateCallback, StateEvents, StateObject, S
 import { IConnection, IOptions } from "../connection";
 import { ESPExceptions } from "../espConnection";
 import { WsSMC } from "../services/wsSMC";
-import { FileSpray, SprayFixedEx, FileSprayService, SprayVariableEx } from "../services/fileSpray";
+import { FileSpray, FileSprayService, UpdateDFUWorkunitEx } from "../services/fileSpray";
 import * as WsTopology from "../services/wsTopology";
 
 const logger = scopedLogger("@hpcc-js/comms/dfuWorkunit.ts");
@@ -95,6 +95,8 @@ export class DFUWorkunit extends StateObject<UDFUWorkunitState, IDFUWorkunitStat
     get expireDays(): number { return this.get("expireDays"); }
     get PreserveFileParts(): boolean { return this.get("PreserveFileParts"); }
     get FileAccessCost(): number { return this.get("FileAccessCost"); }
+    get KbPerSecAve(): number { return this.get("KbPerSecAve"); }
+    get KbPerSec(): number { return this.get("KbPerSec"); }
 
     //  Factories  ---
     static create(optsConnection: IOptions | IConnection, dfuServerQueue: string): Promise<DFUWorkunit> {
@@ -116,7 +118,7 @@ export class DFUWorkunit extends StateObject<UDFUWorkunitState, IDFUWorkunitStat
         return retVal;
     }
 
-    static sprayFixed(server: IOptions | IConnection, request: Partial<SprayFixedEx>): Promise<DFUWorkunit> {
+    static sprayFixed(server: IOptions | IConnection, request: Partial<FileSpray.SprayFixed>): Promise<DFUWorkunit> {
         const service = new FileSprayService(server);
         return service.SprayFixedEx({
             ...request
@@ -128,7 +130,7 @@ export class DFUWorkunit extends StateObject<UDFUWorkunitState, IDFUWorkunitStat
         });
     }
 
-    static sprayVariable(server: IOptions | IConnection, request: Partial<SprayVariableEx>): Promise<DFUWorkunit> {
+    static sprayVariable(server: IOptions | IConnection, request: Partial<FileSpray.SprayVariable>): Promise<DFUWorkunit> {
         const service = new FileSprayService(server);
         return service.SprayVariableEx({
             ...request
@@ -152,6 +154,21 @@ export class DFUWorkunit extends StateObject<UDFUWorkunitState, IDFUWorkunitStat
         });
     }
 
+    update(request: Partial<UpdateDFUWorkunitEx>): Promise<FileSpray.UpdateDFUWorkunitResponse> {
+        return this.connection.UpdateDFUWorkunitEx({
+            wu: {
+                JobName: request?.wu?.JobName ?? this.JobName,
+                isProtected: request?.wu?.isProtected ?? this.isProtected,
+                ID: this.ID,
+                State: this.State
+            },
+            ClusterOrig: this.ClusterName,
+            JobNameOrig: this.JobName,
+            isProtectedOrig: this.isProtected,
+            StateOrig: this.State
+        });
+    }
+
     isComplete(): boolean {
         switch (this.State) {
             case States.Finished:
@@ -184,11 +201,23 @@ export class DFUWorkunit extends StateObject<UDFUWorkunitState, IDFUWorkunitStat
         return !this.isComplete();
     }
 
+    abort(): Promise<FileSpray.AbortDFUWorkunitResponse> {
+        return this.connection.AbortDFUWorkunit({ wuid: this.ID });
+    }
+
+    delete() {
+        return this.DFUWUAction(FileSpray.DFUWUActions.Delete);
+    }
+
     async refresh(full: boolean = false): Promise<this> {
         await this.GetDFUWorkunit();
         return this;
     }
 
+    fetchXML(callback?: void): Promise<FileSpray.DFUWUFileResponse> {
+        return this.DFUWUFile();
+    }
+
     //  Monitoring  ---
     protected _monitor(): void {
         if (this.isComplete()) {
@@ -210,6 +239,30 @@ export class DFUWorkunit extends StateObject<UDFUWorkunitState, IDFUWorkunitStat
         return retVal;
     }
 
+    protected DFUWUFile(_request: Partial<FileSpray.DFUWUFileRequest> = {}): Promise<FileSpray.DFUWUFileResponse> {
+        return this.connection.DFUWUFile({
+            ..._request, Wuid: this.ID
+        }).then(response => {
+            //TODO: additional processing?
+            return response;
+        }).catch((e: ESPExceptions) => {
+            return {} as FileSpray.DFUWUFileResponse;
+        });
+    }
+
+    protected DFUWUAction(actionType: FileSpray.DFUWUActions): Promise<FileSpray.DFUWorkunitsActionResponse> {
+        return this.connection.DFUWorkunitsAction({
+            wuids: { Item: [this.ID] },
+            Type: actionType
+        }).then((response) => {
+            if (actionType === FileSpray.DFUWUActions.Delete) return response;
+            return this.refresh().then(() => {
+                this._monitor();
+                return response;
+            });
+        });
+    }
+
     //  Events  ---
     on(eventID: DFUWorkunitEvents, propIDorCallback: StateCallback | keyof UDFUWorkunitState, callback?: StatePropCallback): this {
         if (this.isCallback(propIDorCallback)) {

package/src/ecl/workunit.ts

@@ -1,4 +1,5 @@
 import { Cache, deepMixinT, IEvent, scopedLogger, StateCallback, StateEvents, StateObject, StatePropCallback, StringAnyMap, XMLNode } from "@hpcc-js/util";
+import { format as d3Format } from "d3-format";
 import { utcFormat, utcParse } from "d3-time-format";
 import { IConnection, IOptions } from "../connection";
 import { ESPExceptions } from "../espConnection";
@@ -14,6 +15,14 @@ import { Timer } from "./timer";
 
 const formatter = utcFormat("%Y-%m-%dT%H:%M:%S.%LZ");
 const parser = utcParse("%Y-%m-%dT%H:%M:%S.%LZ");
+const d3FormatNum = d3Format(",");
+function formatNum(num: number | string): string {
+    if (num && !isNaN(+num)) {
+        return d3FormatNum(+num);
+    }
+    return num as string;
+}
+
 const logger = scopedLogger("workunit.ts");
 
 const WUStateID = WsWorkunits.WUStateID;
@@ -567,7 +576,7 @@ export class Workunit extends StateObject<UWorkunitState, IWorkunitState> implem
                             default:
                                 props[scopeProperty.Name] = scopeProperty.RawValue;
                         }
-                        formattedProps[scopeProperty.Name] = scopeProperty.Formatted ?? props[scopeProperty.Name];
+                        formattedProps[scopeProperty.Name] = formatNum(scopeProperty.Formatted ?? props[scopeProperty.Name]);
 
                     }
                 }

package/src/services/fileSpray.ts

@@ -1,116 +1,31 @@
-import { FileSprayServiceBase, FileSpray } from "./wsdl/FileSpray/v1.23/FileSpray";
+import { FileSprayServiceBase, FileSpray } from "./wsdl/FileSpray/v1.25/FileSpray";
 
 export {
     FileSpray
 };
 
-export interface SprayFixedEx {
-    sourceIP?: string;
-    sourcePlane?: string;
-    sourcePath?: string;
-    srcxml?: string;
-    sourceFormat?: string;
-    sourceRecordSize?: number;
-    destGroup?: string;
-    destLogicalName?: string;
-    overwrite?: boolean;
-    replicate?: boolean;
-    ReplicateOffset?: number;
-    maxConnections?: number;
-    throttle?: number;
-    transferBufferSize?: number;
-    prefix?: string;
-    nosplit?: boolean;
-    norecover?: boolean;
-    compress?: boolean;
-    push?: boolean;
-    pull?: boolean;
-    noCommon?: boolean;
-    encrypt?: string;
-    decrypt?: string;
-    wrap?: boolean;
-    failIfNoSourceFile?: boolean;
-    recordStructurePresent?: boolean;
-    quotedTerminator?: boolean;
-    expireDays?: number;
-    DFUServerQueue?: string;
-}
-
-export interface SprayVariableEx {
-    sourceIP?: string;
-    sourcePlane?: string;
-    sourcePath?: string;
-    srcxml?: string;
-    sourceMaxRecordSize?: number;
-    sourceFormat?: number;
-    NoSourceCsvSeparator?: boolean;
-    sourceCsvSeparate?: string;
-    sourceCsvTerminate?: string;
-    sourceCsvQuote?: string;
-    sourceCsvEscape?: string;
-    sourceRowTag?: string;
-    destGroup?: string;
-    destLogicalName?: string;
-    overwrite?: boolean;
-    replicate?: boolean;
-    ReplicateOffset?: number;
-    maxConnections?: number;
-    throttle?: number;
-    transferBufferSize?: number;
-    prefix?: string;
-    nosplit?: boolean;
-    norecover?: boolean;
-    compress?: boolean;
-    push?: boolean;
-    pull?: boolean;
-    noCommon?: boolean;
-    encrypt?: string;
-    decrypt?: string;
-    failIfNoSourceFile?: boolean;
-    recordStructurePresent?: boolean;
-    quotedTerminator?: boolean;
-    sourceRowPath?: string;
-    isJSON?: boolean;
-    expireDays?: number;
-    DFUServerQueue?: string;
-    srcUsername?: string;
-    srcPassword?: string;
-}
+type UpdateDFUWorkunitMinusWU = Omit<FileSpray.UpdateDFUWorkunit, "wu">;
+type UpdateDFUWorkunitWU = FileSpray.UpdateDFUWorkunit["wu"];
 
-export interface DesprayEx {
-    destGroup?: string;
-    sourceLogicalName?: string;
-    destIP?: string;
-    destPath?: string;
-    destPlane?: string;
-    dstxml?: string;
-    overwrite?: boolean;
-    maxConnections?: number;
-    throttle?: number;
-    transferBufferSize?: number;
-    splitprefix?: string;
-    norecover?: boolean;
-    wrap?: boolean;
-    multiCopy?: boolean;
-    SingleConnection?: boolean;
-    DFUServerQueue?: string;
-    compress?: boolean;
-    encrypt?: string;
-    decrypt?: string;
+export interface UpdateDFUWorkunitEx extends UpdateDFUWorkunitMinusWU {
+    wu?: Partial<UpdateDFUWorkunitWU>
 }
 
 export class FileSprayService extends FileSprayServiceBase {
 
-    SprayFixedEx(request: SprayFixedEx): Promise<FileSpray.SprayFixedResponse> {
+    SprayFixedEx(request: Partial<FileSpray.SprayFixed>): Promise<FileSpray.SprayFixedResponse> {
         return this._connection.send("SprayFixed", request);
     }
 
-    SprayVariableEx(request: SprayVariableEx): Promise<FileSpray.SprayResponse> {
+    SprayVariableEx(request: Partial<FileSpray.SprayVariable>): Promise<FileSpray.SprayResponse> {
         return this._connection.send("SprayVariable", request, "json", false, null, "SprayResponse");
     }
 
-    DesprayEx(request: DesprayEx): Promise<FileSpray.DesprayResponse> {
+    DesprayEx(request: Partial<FileSpray.Despray>): Promise<FileSpray.DesprayResponse> {
         return this._connection.send("Despray", request);
     }
 
+    UpdateDFUWorkunitEx(request: Partial<UpdateDFUWorkunitEx>): Promise<FileSpray.UpdateDFUWorkunitResponse> {
+        return this._connection.send("UpdateDFUWorkunit", request, "json", false, undefined, "UpdateDFUWorkunitResponse");
+    }
 }